McSheep - View of -[3][14]-CPPParser[1]-1140-1140-CPPParser[5]-1153-1163-CPPParser[4]-1172-1183-CP1004379080


CPPParser CPPParser CPPParser
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
CPPParser (full listing) CPPParser (full listing) CPPParser (full listing)
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }
   1.    // $ANTLR 2.7.7 (20060930): "CppParser4Java.g" -> "CPPParser.java"$
   2.    
   3.    /*REMOVE_BEGIN*/
   4.    package org.argouml.language.cpp.reveng;
   5.    /*REMOVE_END*/
   6.    
   7.    import java.util.Hashtable;
   8.    import java.util.List;
   9.    import java.util.ArrayList;
  10.    
  11.    import antlr.TokenBuffer;
  12.    import antlr.TokenStreamException;
  13.    import antlr.TokenStreamIOException;
  14.    import antlr.ANTLRException;
  15.    import antlr.LLkParser;
  16.    import antlr.Token;
  17.    import antlr.TokenStream;
  18.    import antlr.RecognitionException;
  19.    import antlr.NoViableAltException;
  20.    import antlr.MismatchedTokenException;
  21.    import antlr.SemanticException;
  22.    import antlr.ParserSharedInputState;
  23.    import antlr.collections.impl.BitSet;
  24.    
  25.    public class CPPParser extends antlr.LLkParser       implements STDCTokenTypes
  26.     {
  27.    
  28.        
  29.        private Modeler m;
  30.        
  31.        String enclosingClass="";//name of current class
  32.        boolean _td=false; // is type declaration?
  33.        Hashtable symbols=new Hashtable();
  34.        
  35.        
  36.        public boolean qualifiedItemIsOneOf(java.util.BitSet  qiFlags, int lookahead_offset) throws TokenSt...
  37.        {     
  38.          java.util.BitSet qi = qualifiedItemIs(lookahead_offset);
  39.          java.util.BitSet aux=(java.util.BitSet) qi.clone();    
  40.            aux.and(qiFlags);
  41.            return (!aux.isEmpty()); 
  42.        }
  43.        
  44.        
  45.        // This is an important function, but will be replaced with
  46.        // an enhanced predicate in the future, once predicates
  47.        // and/or predicate guards can contain loops.
  48.        //
  49.        // Scan past the ::T::B:: to see what lies beyond.
  50.        // Return QI_TYPE if the qualified item can pose as type name.
  51.        // Note that T::T is NOT a type; it is a constructor.  Also,
  52.        // class T { ... T...} yields the enclosed T as a ctor.  This
  53.        // is probably a type as I separate out the constructor defs/decls,
  54.        // I want it consistent with T::T.
  55.        //
  56.        // In the below examples, I use A,B,T and example types, and
  57.        // a,b as example ids.
  58.        // In the below examples, any A or B may be a
  59.        // qualified template, i.e.,  A<...>
  60.        //
  61.        // T::T outside of class T yields QI_CTOR.
  62.        // T<...>::T outside of class T yields QI_CTOR.
  63.        // T inside of class T {...} yields QI_CTOR.
  64.        // T, ::T, A::T outside of class T yields QI_TYPE.
  65.        // a, ::a,  A::B::a yields qiId
  66.        // a::b yields QI_INVALID
  67.        // ::operator, operator, A::B::operator yield qiOPerator
  68.        // A::*, A::B::* yield QI_PTR_MEMBER
  69.        // ::*, * yields QI_INVALID
  70.        // ::~T, ~T, A::~T yield QI_DTOR
  71.        // ~a, ~A::a, A::~T::, ~T:: yield QI_INVALID
  72.        public java.util.BitSet qualifiedItemIs(int lookahead_offset) throws TokenStreamException
  73.        {
  74.            int value;
  75.            int k = lookahead_offset + 1;
  76.            int final_type_idx = 0;
  77.            boolean scope_found = false;
  78.            // Skip leading "::"
  79.            if (LT(k).getType() == SCOPE)
  80.            {
  81.                k++; 
  82.                scope_found = true;
  83.            }
  84.            // Skip sequences of T:: or T<...>::
  85.            //printf("support.cpp qualifiedItemIs while reached k %d type %d isType %d, isClass %d, guessing %...
  86.            //    k,LT(k)->getType(),isTypeName((LT(k)->getText()).data()),isClassName((LT(k)->getText()).data())...
  87.            while ((LT(k).getType() == ID) && (isTypeName(LT(k).getText())))
  88.            {// If this type is the same as the last type, then ctor
  89.                if ((final_type_idx != 0) && (LT(final_type_idx).getText().equals(LT(k).getText())))
  90.                {// Like T::T
  91.                // As an extra check, do not allow T::T::
  92.                    if (LT(k+1).getType() == SCOPE)
  93.                    {    //printf("support.cpp qualifiedItemIs QI_INVALID returned\n");
  94.                        return CPPvariables.QI_INVALID;
  95.                    } 
  96.                    else 
  97.                    {//printf("support.cpp qualifiedItemIs QI_CTOR returned\n");
  98.                        return CPPvariables.QI_CTOR;
  99.                    }
 100.                }
 101.    
 102.                // Record this as the most recent type seen in the series
 103.                final_type_idx = k;
 104.            
 105.                //printf("support.cpp qualifiedItemIs if step reached final_type_idx %d\n",final_type_idx);
 106.            
 107.                // Skip this token
 108.                k++;
 109.    
 110.                // Skip over any template qualifiers <...>
 111.                // I believe that "T<..." cannot be anything valid but a template
 112.                if (LT(k).getType() == LESSTHAN)
 113.                {
 114.                    value=skipTemplateQualifiers(k);
 115.                    if (value==k)
 116.                    {//printf("support.cpp qualifiedItemIs QI_INVALID(2) returned\n");
 117.                        return CPPvariables.QI_INVALID;
 118.                    }
 119.                    else
 120.                        k=value;
 121.                    //printf("support.cpp qualifiedItemIs template skipped, k %d\n",k);
 122.                    // k has been updated to token following <...>
 123.                }
 124.                if (LT(k).getType() == SCOPE)
 125.                // Skip the "::" and keep going
 126.                {
 127.                    k++; 
 128.                    scope_found = true;
 129.                }
 130.                else 
 131.                {// Series terminated -- last ID in the sequence was a type
 132.                // Return ctor if last type is in containing class
 133.                // We already checked for T::T inside loop
 134.                    if ( enclosingClass.equals(LT(final_type_idx).getText()))
 135.                    {    // Like class T  T()
 136.                        //printf("support.cpp qualifiedItemIs QI_CTOR(2) returned\n");
 137.                        return CPPvariables.QI_CTOR;
 138.                    } 
 139.                    else 
 140.                    {//printf("support.cpp qualifiedItemIs QI_TYPE returned\n");
 141.                        return CPPvariables.QI_TYPE;
 142.                    }
 143.                }
 144.            }
 145.            // LT(k) is not an ID, or it is an ID but not a typename.
 146.            //printf("support.cpp qualifiedItemIs second switch reached\n");
 147.            switch (LT(k).getType())
 148.            {
 149.                case ID:
 150.                    // ID but not a typename
 151.                    // Do not allow id::
 152.                    if (LT(k+1).getType() == SCOPE)
 153.                    {
 154.                    //printf("support.cpp qualifiedItemIs QI_INVALID(3) returned\n");
 155.                        return CPPvariables.QI_INVALID;
 156.                    }
 157.                    if (enclosingClass.equals(LT(k).getText()))
 158.                    {    // Like class T  T()
 159.                        //printf("support.cpp qualifiedItemIs QI_CTOR(3) returned\n");
 160.                        return CPPvariables.QI_CTOR;
 161.                    }
 162.                    else 
 163.                    {
 164.                        if (scope_found)
 165.                            // DW 25/10/03 Assume type if at least one SCOPE present (test12.i)
 166.                            return CPPvariables.QI_TYPE;
 167.                            else             
 168.                            //printf("support.cpp qualifiedItemIs QI_VAR returned\n");
 169.                            return CPPvariables.QI_VAR;    // DW 19/03/04 was QI_ID Could be function?
 170.                    }
 171.                case TILDE:
 172.                    // check for dtor
 173.                    if ((LT(k+1).getType() == ID) && (isTypeName(LT(k+1).getText())) &&(LT(k+2).getType() != SCOPE))...
 174.                    {    // Like ~B or A::B::~B
 175.                         // Also (incorrectly?) matches ::~A.
 176.                        //printf("support.cpp qualifiedItemIs QI_DTOR returned\n");
 177.                        return CPPvariables.QI_DTOR;
 178.                    } 
 179.                    else 
 180.                    {    // ~a or ~A::a is QI_INVALID
 181.                        //printf("support.cpp qualifiedItemIs QI_INVALID(4) returned\n");
 182.                        return CPPvariables.QI_INVALID;
 183.                    }
 184.                case STAR:
 185.                    // Like A::*
 186.                    // Do not allow * or ::*
 187.                    if (final_type_idx == 0)
 188.                    {    // Haven't seen a type yet
 189.                        //printf("support.cpp qualifiedItemIs QI_INVALID(5) returned\n");
 190.                        return CPPvariables.QI_INVALID;
 191.                    } 
 192.                    else 
 193.                    {    //printf("support.cpp qualifiedItemIs QI_PTR_MEMBER returned\n");
 194.                        return CPPvariables.QI_PTR_MEMBER;
 195.                    }
 196.                case OPERATOR:
 197.                    // Like A::operator, ::operator, or operator
 198.                    //printf("support.cpp qualifiedItemIs QI_OPERATOR returned\n");
 199.                    return CPPvariables.QI_OPERATOR;
 200.                default:
 201.                    // Something that neither starts with :: or ID, or
 202.                    // a :: not followed by ID, operator, ~, or *
 203.                    //printf("support.cpp qualifiedItemIs QI_INVALID(6) returned\n");
 204.                    return CPPvariables.QI_INVALID;
 205.            }
 206.        }
 207.    
 208.        // Skip over <...>.  This correctly handles nested <> and (), e.g:
 209.        //    <T>
 210.        //    < (i>3) >
 211.        //    < T2<...> >
 212.        // but not
 213.        //    < i>3 >
 214.        //
 215.        // On input, kInOut is the index of the "<"
 216.        // On output, if the return is true, then 
 217.        //                kInOut is the index of the token after ">"
 218.        //            else
 219.        //                kInOut is unchanged
 220.    
 221.        public int skipTemplateQualifiers(int kInOut)  throws TokenStreamException
 222.        {
 223.            // Start after "<"
 224.            int k = kInOut + 1;
 225.            int value;
 226.            while (LT(k).getType() != GREATERTHAN) // scan to end of <...>
 227.            {
 228.                switch (LT(k).getType())
 229.                {
 230.                    case EOF:
 231.                        return kInOut;
 232.                    case LESSTHAN:
 233.                        value=skipTemplateQualifiers(k);
 234.                        if (value==k)
 235.                        {
 236.                            return kInOut;
 237.                        }
 238.                        else
 239.                            k=value;
 240.                        break;
 241.                    case LPAREN:
 242.                        value=skipNestedParens(k);
 243.                        if (value==k)
 244.                        {
 245.                            return kInOut;
 246.                        }
 247.                        else
 248.                            k=value;
 249.                        break;
 250.                    default:
 251.                        k++;     // skip everything else
 252.                        break;
 253.                }
 254.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 255.                {
 256.                    return kInOut;
 257.                }
 258.            }
 259.    
 260.        // Update output argument to point past ">"
 261.        kInOut = k + 1;
 262.        return kInOut;
 263.        }
 264.    
 265.        // Skip over (...).  This correctly handles nested (), e.g:
 266.        //    (i>3, (i>5))
 267.        //
 268.        // On input, kInOut is the index of the "("
 269.        // On output, if the return is true, then 
 270.        //                kInOut is the index of the token after ")"
 271.        //            else
 272.        //                kInOut is unchanged
 273.        public int skipNestedParens(int kInOut)  throws TokenStreamException
 274.        {    
 275.            // Start after "("
 276.            int k = kInOut + 1;
 277.            int value;
 278.            while (LT(k).getType() != RPAREN)   // scan to end of (...)
 279.            {
 280.                switch (LT(k).getType())
 281.                {
 282.                    case EOF:
 283.                        return kInOut;
 284.                    case LPAREN:
 285.                        value=skipNestedParens(k);
 286.                        if (value==k)
 287.                        {
 288.                            return kInOut;
 289.                        }
 290.                        else
 291.                            k=value;
 292.                        break;
 293.                    default:
 294.                        k++;     // skip everything else
 295.                        break;
 296.                }
 297.                if (k > CPPvariables.MAX_TEMPLATE_TOKEN_SCAN)
 298.                {
 299.                    return kInOut;
 300.                }
 301.            }
 302.            // Update output argument to point past ")"
 303.            kInOut = k + 1;
 304.            return kInOut;
 305.        }
 306.    
 307.        // Return true if "::blah" or "fu::bar<args>::..." found.
 308.        public boolean scopedItem(int k)  throws TokenStreamException
 309.        {
 310.            //printf("support.cpp scopedItem k %d\n",k);
 311.            return (LT(k).getType()==SCOPE ||
 312.                (LT(k).getType()==ID && !finalQualifier(k)));
 313.        }
 314.    
 315.        // Return true if ID<...> or ID is last item in qualified item list.
 316.        // Return false if LT(k) is not an ID.
 317.        // ID must be a type to check for ID<...>,
 318.        // or else we would get confused by "i<3"
 319.        public boolean finalQualifier(int k)  throws TokenStreamException
 320.        {
 321.            if (LT(k).getType()==ID)
 322.            {
 323.                if ((isTypeName(LT(k).getText())) && (LT(k+1).getType()==LESSTHAN))
 324.                {
 325.                    // Starts with "T<".  Skip <...>
 326.                    k++;
 327.                    k=skipTemplateQualifiers(k);
 328.                } 
 329.                else 
 330.                {
 331.                    // skip ID;
 332.                    k++;
 333.                }
 334.                return (LT(k).getType() != SCOPE );
 335.            } 
 336.            else 
 337.            {    // not an ID
 338.                return false;
 339.            }
 340.        }
 341.    
 342.        /*
 343.         * Return true if 's' can pose as a type name
 344.          */
 345.        public boolean isTypeName(String s)
 346.        {
 347.            String type="";
 348.            if (!symbols.containsKey(s))
 349.            {
 350.                //printf("support.cpp isTypeName %s not found\n",s);
 351.                return false;
 352.            }
 353.            else
 354.                type=(String) symbols.get(s);
 355.            if (type.equals(CPPvariables.OT_TYPE_DEF)||
 356.                type.equals(CPPvariables.OT_ENUM)||
 357.                type.equals(CPPvariables.OT_CLASS)||
 358.                type.equals(CPPvariables.OT_STRUCT)||
 359.                type.equals(CPPvariables.OT_UNION))
 360.            {
 361.                return true;
 362.            }
 363.            return false;
 364.        }
 365.        
 366.        public void declaratorID(String id, java.util.BitSet qi)
 367.        {
 368.            if ((qi.equals(CPPvariables.QI_TYPE)) || (_td))    // Check for type declaration
 369.            {
 370.                if (!symbols.containsKey(id))
 371.                    symbols.put(id, CPPvariables.OT_TYPE_DEF);
 372.            }
 373.        }
 374.    
 375.    protected CPPParser(TokenBuffer tokenBuf, int k) {
 376.      super(tokenBuf,k);
 377.      tokenNames = _tokenNames;
 378.    }
 379.    
 380.    public CPPParser(TokenBuffer tokenBuf) {
 381.      this(tokenBuf,2);
 382.    }
 383.    
 384.    protected CPPParser(TokenStream lexer, int k) {
 385.      super(lexer,k);
 386.      tokenNames = _tokenNames;
 387.    }
 388.    
 389.    public CPPParser(TokenStream lexer) {
 390.      this(lexer,2);
 391.    }
 392.    
 393.    public CPPParser(ParserSharedInputState state) {
 394.      super(state,2);
 395.      tokenNames = _tokenNames;
 396.    }
 397.    
 398.        public final void translation_unit(
 399.            Modeler modeler
 400.        ) throws RecognitionException, TokenStreamException {
 401.            
 402.            
 403.                    if(!symbols.containsKey("std"))
 404.                        symbols.put("std",CPPvariables.OT_TYPE_DEF);
 405.                    m = modeler;
 406.                
 407.            
 408.            if ( inputState.guessing==0 ) {
 409.                m.beginTranslationUnit();
 410.            }
 411.            {
 412.            int _cnt3=0;
 413.            _loop3:
 414.            do {
 415.                if ((_tokenSet_0.member(LA(1)))) {
 416.                    external_declaration();
 417.                }
 418.                else {
 419.                    if ( _cnt3>=1 ) { break _loop3; } else {throw new NoViableAltException(LT(1), getFilename());}
 420.                }
 421.                
 422.                _cnt3++;
 423.            } while (true);
 424.            }
 425.            match(Token.EOF_TYPE);
 426.            if ( inputState.guessing==0 ) {
 427.                m.endTranslationUnit();
 428.            }
 429.        }
 430.        
 431.        public final void external_declaration() throws RecognitionException, TokenStreamException {
 432.            
 433.            String s="";
 434.            
 435.            {
 436.            switch ( LA(1)) {
 437.            case LITERAL_namespace:
 438.            {
 439.                decl_namespace();
 440.                break;
 441.            }
 442.            case SEMICOLON:
 443.            {
 444.                match(SEMICOLON);
 445.                break;
 446.            }
 447.            default:
 448.                boolean synPredMatched7 = false;
 449.                if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 450.                    int _m7 = mark();
 451.                    synPredMatched7 = true;
 452.                    inputState.guessing++;
 453.                    try {
 454.                        {
 455.                        match(LITERAL_template);
 456.                        match(LESSTHAN);
 457.                        match(GREATERTHAN);
 458.                        }
 459.                    }
 460.                    catch (RecognitionException pe) {
 461.                        synPredMatched7 = false;
 462.                    }
 463.                    rewind(_m7);
 464.    inputState.guessing--;
 465.                }
 466.                if ( synPredMatched7 ) {
 467.                    match(LITERAL_template);
 468.                    match(LESSTHAN);
 469.                    match(GREATERTHAN);
 470.                    declaration();
 471.                }
 472.                else {
 473.                    boolean synPredMatched10 = false;
 474.                    if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 475.                        int _m10 = mark();
 476.                        synPredMatched10 = true;
 477.                        inputState.guessing++;
 478.                        try {
 479.                            {
 480.                            {
 481.                            switch ( LA(1)) {
 482.                            case LITERAL_typedef:
 483.                            {
 484.                                match(LITERAL_typedef);
 485.                                break;
 486.                            }
 487.                            case LITERAL_class:
 488.                            case LITERAL_struct:
 489.                            case LITERAL_union:
 490.                            {
 491.                                break;
 492.                            }
 493.                            default:
 494.                            {
 495.                                throw new NoViableAltException(LT(1), getFilename());
 496.                            }
 497.                            }
 498.                            }
 499.                            class_head();
 500.                            }
 501.                        }
 502.                        catch (RecognitionException pe) {
 503.                            synPredMatched10 = false;
 504.                        }
 505.                        rewind(_m10);
 506.    inputState.guessing--;
 507.                    }
 508.                    if ( synPredMatched10 ) {
 509.                        declaration();
 510.                    }
 511.                    else {
 512.                        boolean synPredMatched12 = false;
 513.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 514.                            int _m12 = mark();
 515.                            synPredMatched12 = true;
 516.                            inputState.guessing++;
 517.                            try {
 518.                                {
 519.                                template_head();
 520.                                class_head();
 521.                                }
 522.                            }
 523.                            catch (RecognitionException pe) {
 524.                                synPredMatched12 = false;
 525.                            }
 526.                            rewind(_m12);
 527.    inputState.guessing--;
 528.                        }
 529.                        if ( synPredMatched12 ) {
 530.                            template_head();
 531.                            declaration();
 532.                        }
 533.                        else {
 534.                            boolean synPredMatched15 = false;
 535.                            if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
 536.                                int _m15 = mark();
 537.                                synPredMatched15 = true;
 538.                                inputState.guessing++;
 539.                                try {
 540.                                    {
 541.                                    match(LITERAL_enum);
 542.                                    {
 543.                                    switch ( LA(1)) {
 544.                                    case ID:
 545.                                    {
 546.                                        match(ID);
 547.                                        break;
 548.                                    }
 549.                                    case LCURLY:
 550.                                    {
 551.                                        break;
 552.                                    }
 553.                                    default:
 554.                                    {
 555.                                        throw new NoViableAltException(LT(1), getFilename());
 556.                                    }
 557.                                    }
 558.                                    }
 559.                                    match(LCURLY);
 560.                                    }
 561.                                }
 562.                                catch (RecognitionException pe) {
 563.                                    synPredMatched15 = false;
 564.                                }
 565.                                rewind(_m15);
 566.    inputState.guessing--;
 567.                            }
 568.                            if ( synPredMatched15 ) {
 569.                                enum_specifier();
 570.                                {
 571.                                switch ( LA(1)) {
 572.                                case ID:
 573.                                case LITERAL__stdcall:
 574.                                case LITERAL___stdcall:
 575.                                case LPAREN:
 576.                                case OPERATOR:
 577.                                case LITERAL_this:
 578.                                case LITERAL_true:
 579.                                case LITERAL_false:
 580.                                case STAR:
 581.                                case AMPERSAND:
 582.                                case TILDE:
 583.                                case SCOPE:
 584.                                case LITERAL__cdecl:
 585.                                case LITERAL___cdecl:
 586.                                case LITERAL__near:
 587.                                case LITERAL___near:
 588.                                case LITERAL__far:
 589.                                case LITERAL___far:
 590.                                case LITERAL___interrupt:
 591.                                case LITERAL_pascal:
 592.                                case LITERAL__pascal:
 593.                                case LITERAL___pascal:
 594.                                {
 595.                                    init_declarator_list();
 596.                                    break;
 597.                                }
 598.                                case SEMICOLON:
 599.                                {
 600.                                    break;
 601.                                }
 602.                                default:
 603.                                {
 604.                                    throw new NoViableAltException(LT(1), getFilename());
 605.                                }
 606.                                }
 607.                                }
 608.                                match(SEMICOLON);
 609.                            }
 610.                            else {
 611.                                boolean synPredMatched19 = false;
 612.                                if (((_tokenSet_3.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
 613.                                    int _m19 = mark();
 614.                                    synPredMatched19 = true;
 615.                                    inputState.guessing++;
 616.                                    try {
 617.                                        {
 618.                                        {
 619.                                        switch ( LA(1)) {
 620.                                        case LITERAL_template:
 621.                                        {
 622.                                            template_head();
 623.                                            break;
 624.                                        }
 625.                                        case ID:
 626.                                        case LITERAL_inline:
 627.                                        case LITERAL__inline:
 628.                                        case LITERAL___inline:
 629.                                        case LITERAL_virtual:
 630.                                        case TILDE:
 631.                                        case SCOPE:
 632.                                        {
 633.                                            break;
 634.                                        }
 635.                                        default:
 636.                                        {
 637.                                            throw new NoViableAltException(LT(1), getFilename());
 638.                                        }
 639.                                        }
 640.                                        }
 641.                                        dtor_head();
 642.                                        match(LCURLY);
 643.                                        }
 644.                                    }
 645.                                    catch (RecognitionException pe) {
 646.                                        synPredMatched19 = false;
 647.                                    }
 648.                                    rewind(_m19);
 649.    inputState.guessing--;
 650.                                }
 651.                                if ( synPredMatched19 ) {
 652.                                    {
 653.                                    switch ( LA(1)) {
 654.                                    case LITERAL_template:
 655.                                    {
 656.                                        template_head();
 657.                                        break;
 658.                                    }
 659.                                    case ID:
 660.                                    case LITERAL_inline:
 661.                                    case LITERAL__inline:
 662.                                    case LITERAL___inline:
 663.                                    case LITERAL_virtual:
 664.                                    case TILDE:
 665.                                    case SCOPE:
 666.                                    {
 667.                                        break;
 668.                                    }
 669.                                    default:
 670.                                    {
 671.                                        throw new NoViableAltException(LT(1), getFilename());
 672.                                    }
 673.                                    }
 674.                                    }
 675.                                    dtor_head();
 676.                                    dtor_body();
 677.                                }
 678.                                else {
 679.                                    boolean synPredMatched23 = false;
 680.                                    if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 681.                                        int _m23 = mark();
 682.                                        synPredMatched23 = true;
 683.                                        inputState.guessing++;
 684.                                        try {
 685.                                            {
 686.                                            {
 687.                                            if ((true) && (true)) {
 688.                                                ctor_decl_spec();
 689.                                            }
 690.                                            else {
 691.                                            }
 692.                                            
 693.                                            }
 694.                                            if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 695.                                              throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 696.                                            }
 697.                                        }
 698.                                        catch (RecognitionException pe) {
 699.                                            synPredMatched23 = false;
 700.                                        }
 701.                                        rewind(_m23);
 702.    inputState.guessing--;
 703.                                    }
 704.                                    if ( synPredMatched23 ) {
 705.                                        ctor_definition();
 706.                                    }
 707.                                    else {
 708.                                        boolean synPredMatched26 = false;
 709.                                        if (((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
 710.                                            int _m26 = mark();
 711.                                            synPredMatched26 = true;
 712.                                            inputState.guessing++;
 713.                                            try {
 714.                                                {
 715.                                                {
 716.                                                switch ( LA(1)) {
 717.                                                case LITERAL_inline:
 718.                                                {
 719.                                                    match(LITERAL_inline);
 720.                                                    break;
 721.                                                }
 722.                                                case ID:
 723.                                                case OPERATOR:
 724.                                                case SCOPE:
 725.                                                {
 726.                                                    break;
 727.                                                }
 728.                                                default:
 729.                                                {
 730.                                                    throw new NoViableAltException(LT(1), getFilename());
 731.                                                }
 732.                                                }
 733.                                                }
 734.                                                scope_override();
 735.                                                conversion_function_decl_or_def();
 736.                                                }
 737.                                            }
 738.                                            catch (RecognitionException pe) {
 739.                                                synPredMatched26 = false;
 740.                                            }
 741.                                            rewind(_m26);
 742.    inputState.guessing--;
 743.                                        }
 744.                                        if ( synPredMatched26 ) {
 745.                                            {
 746.                                            switch ( LA(1)) {
 747.                                            case LITERAL_inline:
 748.                                            {
 749.                                                match(LITERAL_inline);
 750.                                                break;
 751.                                            }
 752.                                            case ID:
 753.                                            case OPERATOR:
 754.                                            case SCOPE:
 755.                                            {
 756.                                                break;
 757.                                            }
 758.                                            default:
 759.                                            {
 760.                                                throw new NoViableAltException(LT(1), getFilename());
 761.                                            }
 762.                                            }
 763.                                            }
 764.                                            s=scope_override();
 765.                                            conversion_function_decl_or_def();
 766.                                        }
 767.                                        else {
 768.                                            boolean synPredMatched29 = false;
 769.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 770.                                                int _m29 = mark();
 771.                                                synPredMatched29 = true;
 772.                                                inputState.guessing++;
 773.                                                try {
 774.                                                    {
 775.                                                    declaration_specifiers();
 776.                                                    function_declarator();
 777.                                                    match(SEMICOLON);
 778.                                                    }
 779.                                                }
 780.                                                catch (RecognitionException pe) {
 781.                                                    synPredMatched29 = false;
 782.                                                }
 783.                                                rewind(_m29);
 784.    inputState.guessing--;
 785.                                            }
 786.                                            if ( synPredMatched29 ) {
 787.                                                declaration();
 788.                                            }
 789.                                            else {
 790.                                                boolean synPredMatched31 = false;
 791.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 792.                                                    int _m31 = mark();
 793.                                                    synPredMatched31 = true;
 794.                                                    inputState.guessing++;
 795.                                                    try {
 796.                                                        {
 797.                                                        declaration_specifiers();
 798.                                                        function_declarator();
 799.                                                        match(LCURLY);
 800.                                                        }
 801.                                                    }
 802.                                                    catch (RecognitionException pe) {
 803.                                                        synPredMatched31 = false;
 804.                                                    }
 805.                                                    rewind(_m31);
 806.    inputState.guessing--;
 807.                                                }
 808.                                                if ( synPredMatched31 ) {
 809.                                                    if ( inputState.guessing==0 ) {
 810.                                                        m.beginFunctionDefinition();
 811.                                                    }
 812.                                                    function_definition();
 813.                                                    if ( inputState.guessing==0 ) {
 814.                                                        m.endFunctionDefinition();
 815.                                                    }
 816.                                                }
 817.                                                else {
 818.                                                    boolean synPredMatched33 = false;
 819.                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 820.                                                        int _m33 = mark();
 821.                                                        synPredMatched33 = true;
 822.                                                        inputState.guessing++;
 823.                                                        try {
 824.                                                            {
 825.                                                            declaration_specifiers();
 826.                                                            function_declarator();
 827.                                                            declaration();
 828.                                                            }
 829.                                                        }
 830.                                                        catch (RecognitionException pe) {
 831.                                                            synPredMatched33 = false;
 832.                                                        }
 833.                                                        rewind(_m33);
 834.    inputState.guessing--;
 835.                                                    }
 836.                                                    if ( synPredMatched33 ) {
 837.                                                        function_definition();
 838.                                                    }
 839.                                                    else {
 840.                                                        boolean synPredMatched36 = false;
 841.                                                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
 842.                                                            int _m36 = mark();
 843.                                                            synPredMatched36 = true;
 844.                                                            inputState.guessing++;
 845.                                                            try {
 846.                                                                {
 847.                                                                template_head();
 848.                                                                declaration_specifiers();
 849.                                                                {
 850.                                                                switch ( LA(1)) {
 851.                                                                case ID:
 852.                                                                case LITERAL__stdcall:
 853.                                                                case LITERAL___stdcall:
 854.                                                                case LPAREN:
 855.                                                                case OPERATOR:
 856.                                                                case LITERAL_this:
 857.                                                                case LITERAL_true:
 858.                                                                case LITERAL_false:
 859.                                                                case STAR:
 860.                                                                case AMPERSAND:
 861.                                                                case TILDE:
 862.                                                                case SCOPE:
 863.                                                                case LITERAL__cdecl:
 864.                                                                case LITERAL___cdecl:
 865.                                                                case LITERAL__near:
 866.                                                                case LITERAL___near:
 867.                                                                case LITERAL__far:
 868.                                                                case LITERAL___far:
 869.                                                                case LITERAL___interrupt:
 870.                                                                case LITERAL_pascal:
 871.                                                                case LITERAL__pascal:
 872.                                                                case LITERAL___pascal:
 873.                                                                {
 874.                                                                    init_declarator_list();
 875.                                                                    break;
 876.                                                                }
 877.                                                                case SEMICOLON:
 878.                                                                {
 879.                                                                    break;
 880.                                                                }
 881.                                                                default:
 882.                                                                {
 883.                                                                    throw new NoViableAltException(LT(1), getFilename());
 884.                                                                }
 885.                                                                }
 886.                                                                }
 887.                                                                match(SEMICOLON);
 888.                                                                }
 889.                                                            }
 890.                                                            catch (RecognitionException pe) {
 891.                                                                synPredMatched36 = false;
 892.                                                            }
 893.                                                            rewind(_m36);
 894.    inputState.guessing--;
 895.                                                        }
 896.                                                        if ( synPredMatched36 ) {
 897.                                                            template_head();
 898.                                                            declaration_specifiers();
 899.                                                            {
 900.                                                            switch ( LA(1)) {
 901.                                                            case ID:
 902.                                                            case LITERAL__stdcall:
 903.                                                            case LITERAL___stdcall:
 904.                                                            case LPAREN:
 905.                                                            case OPERATOR:
 906.                                                            case LITERAL_this:
 907.                                                            case LITERAL_true:
 908.                                                            case LITERAL_false:
 909.                                                            case STAR:
 910.                                                            case AMPERSAND:
 911.                                                            case TILDE:
 912.                                                            case SCOPE:
 913.                                                            case LITERAL__cdecl:
 914.                                                            case LITERAL___cdecl:
 915.                                                            case LITERAL__near:
 916.                                                            case LITERAL___near:
 917.                                                            case LITERAL__far:
 918.                                                            case LITERAL___far:
 919.                                                            case LITERAL___interrupt:
 920.                                                            case LITERAL_pascal:
 921.                                                            case LITERAL__pascal:
 922.                                                            case LITERAL___pascal:
 923.                                                            {
 924.                                                                init_declarator_list();
 925.                                                                break;
 926.                                                            }
 927.                                                            case SEMICOLON:
 928.                                                            {
 929.                                                                break;
 930.                                                            }
 931.                                                            default:
 932.                                                            {
 933.                                                                throw new NoViableAltException(LT(1), getFilename());
 934.                                                            }
 935.                                                            }
 936.                                                            }
 937.                                                            match(SEMICOLON);
 938.                                                        }
 939.                                                        else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
 940.                                                            template_head();
 941.                                                            {
 942.                                                            boolean synPredMatched40 = false;
 943.                                                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
 944.                                                                int _m40 = mark();
 945.                                                                synPredMatched40 = true;
 946.                                                                inputState.guessing++;
 947.                                                                try {
 948.                                                                    {
 949.                                                                    ctor_decl_spec();
 950.                                                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
 951.                                                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
 952.                                                                    }
 953.                                                                }
 954.                                                                catch (RecognitionException pe) {
 955.                                                                    synPredMatched40 = false;
 956.                                                                }
 957.                                                                rewind(_m40);
 958.    inputState.guessing--;
 959.                                                            }
 960.                                                            if ( synPredMatched40 ) {
 961.                                                                ctor_definition();
 962.                                                            }
 963.                                                            else {
 964.                                                                boolean synPredMatched42 = false;
 965.                                                                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
 966.                                                                    int _m42 = mark();
 967.                                                                    synPredMatched42 = true;
 968.                                                                    inputState.guessing++;
 969.                                                                    try {
 970.                                                                        {
 971.                                                                        declaration_specifiers();
 972.                                                                        function_declarator();
 973.                                                                        match(SEMICOLON);
 974.                                                                        }
 975.                                                                    }
 976.                                                                    catch (RecognitionException pe) {
 977.                                                                        synPredMatched42 = false;
 978.                                                                    }
 979.                                                                    rewind(_m42);
 980.    inputState.guessing--;
 981.                                                                }
 982.                                                                if ( synPredMatched42 ) {
 983.                                                                    declaration();
 984.                                                                }
 985.                                                                else {
 986.                                                                    boolean synPredMatched44 = false;
 987.                                                                    if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
 988.                                                                        int _m44 = mark();
 989.                                                                        synPredMatched44 = true;
 990.                                                                        inputState.guessing++;
 991.                                                                        try {
 992.                                                                            {
 993.                                                                            declaration_specifiers();
 994.                                                                            function_declarator();
 995.                                                                            match(LCURLY);
 996.                                                                            }
 997.                                                                        }
 998.                                                                        catch (RecognitionException pe) {
 999.                                                                            synPredMatched44 = false;
1000.                                                                        }
1001.                                                                        rewind(_m44);
1002.    inputState.guessing--;
1003.                                                                    }
1004.                                                                    if ( synPredMatched44 ) {
1005.                                                                        function_definition();
1006.                                                                    }
1007.                                                                    else {
1008.                                                                        throw new NoViableAltException(LT(1), getFilename());
1009.                                                                    }
1010.                                                                    }}
1011.                                                                    }
1012.                                                                }
1013.                                                                else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) {
1014.                                                                    declaration();
1015.                                                                }
1016.                                                            else {
1017.                                                                throw new NoViableAltException(LT(1), getFilename());
1018.                                                            }
1019.                                                            }}}}}}}}}}}
1020.                                                            }
1021.                                                        }
1022.                                                        
1023.        public final void declaration() throws RecognitionException, TokenStreamException {
1024.            
1025.            
1026.            boolean synPredMatched106 = false;
1027.            if (((LA(1)==LITERAL_extern) && (LA(2)==StringLiteral))) {
1028.                int _m106 = mark();
1029.                synPredMatched106 = true;
1030.                inputState.guessing++;
1031.                try {
1032.                    {
1033.                    match(LITERAL_extern);
1034.                    match(StringLiteral);
1035.                    }
1036.                }
1037.                catch (RecognitionException pe) {
1038.                    synPredMatched106 = false;
1039.                }
1040.                rewind(_m106);
1041.    inputState.guessing--;
1042.            }
1043.            if ( synPredMatched106 ) {
1044.                linkage_specification();
1045.            }
1046.            else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
1047.                declaration_specifiers();
1048.                {
1049.                switch ( LA(1)) {
1050.                case ID:
1051.                case COMMA:
1052.                case LITERAL__stdcall:
1053.                case LITERAL___stdcall:
1054.                case LPAREN:
1055.                case OPERATOR:
1056.                case LITERAL_this:
1057.                case LITERAL_true:
1058.                case LITERAL_false:
1059.                case STAR:
1060.                case AMPERSAND:
1061.                case TILDE:
1062.                case SCOPE:
1063.                case LITERAL__cdecl:
1064.                case LITERAL___cdecl:
1065.                case LITERAL__near:
1066.                case LITERAL___near:
1067.                case LITERAL__far:
1068.                case LITERAL___far:
1069.                case LITERAL___interrupt:
1070.                case LITERAL_pascal:
1071.                case LITERAL__pascal:
1072.                case LITERAL___pascal:
1073.                {
1074.                    {
1075.                    switch ( LA(1)) {
1076.                    case COMMA:
1077.                    {
1078.                        match(COMMA);
1079.                        break;
1080.                    }
1081.                    case ID:
1082.                    case LITERAL__stdcall:
1083.                    case LITERAL___stdcall:
1084.                    case LPAREN:
1085.                    case OPERATOR:
1086.                    case LITERAL_this:
1087.                    case LITERAL_true:
1088.                    case LITERAL_false:
1089.                    case STAR:
1090.                    case AMPERSAND:
1091.                    case TILDE:
1092.                    case SCOPE:
1093.                    case LITERAL__cdecl:
1094.                    case LITERAL___cdecl:
1095.                    case LITERAL__near:
1096.                    case LITERAL___near:
1097.                    case LITERAL__far:
1098.                    case LITERAL___far:
1099.                    case LITERAL___interrupt:
1100.                    case LITERAL_pascal:
1101.                    case LITERAL__pascal:
1102.                    case LITERAL___pascal:
1103.                    {
1104.                        break;
1105.                    }
1106.                    default:
1107.                    {
1108.                        throw new NoViableAltException(LT(1), getFilename());
1109.                    }
1110.                    }
1111.                    }
1112.                    init_declarator_list();
1113.                    break;
1114.                }
1115.                case SEMICOLON:
1116.                {
1117.                    break;
1118.                }
1119.                default:
1120.                {
1121.                    throw new NoViableAltException(LT(1), getFilename());
1122.                }
1123.                }
1124.                }
1125.                match(SEMICOLON);
1126.            }
1127.            else if ((LA(1)==LITERAL_using)) {
1128.                using_declaration();
1129.            }
1130.            else {
1131.                throw new NoViableAltException(LT(1), getFilename());
1132.            }
1133.            
1134.        }
1135.        
1136.        public final void class_head() throws RecognitionException, TokenStreamException {
1137.            
1138.            
1139.            {
1140.            switch ( LA(1)) {
1141.            case LITERAL_struct:
1142.            {
1143.                match(LITERAL_struct);
1144.                break;
1145.            }
1146.            case LITERAL_union:
1147.            {
1148.                match(LITERAL_union);
1149.                break;
1150.            }
1151.            case LITERAL_class:
1152.            {
1153.                match(LITERAL_class);
1154.                break;
1155.            }
1156.            default:
1157.            {
1158.                throw new NoViableAltException(LT(1), getFilename());
1159.            }
1160.            }
1161.            }
1162.            {
1163.            switch ( LA(1)) {
1164.            case ID:
1165.            {
1166.                match(ID);
1167.                {
1168.                switch ( LA(1)) {
1169.                case LESSTHAN:
1170.                {
1171.                    match(LESSTHAN);
1172.                    template_argument_list();
1173.                    match(GREATERTHAN);
1174.                    break;
1175.                }
1176.                case LCURLY:
1177.                case COLON:
1178.                {
1179.                    break;
1180.                }
1181.                default:
1182.                {
1183.                    throw new NoViableAltException(LT(1), getFilename());
1184.                }
1185.                }
1186.                }
1187.                {
1188.                switch ( LA(1)) {
1189.                case COLON:
1190.                {
1191.                    base_clause();
1192.                    break;
1193.                }
1194.                case LCURLY:
1195.                {
1196.                    break;
1197.                }
1198.                default:
1199.                {
1200.                    throw new NoViableAltException(LT(1), getFilename());
1201.                }
1202.                }
1203.                }
1204.                break;
1205.            }
1206.            case LCURLY:
1207.            {
1208.                break;
1209.            }
1210.            default:
1211.            {
1212.                throw new NoViableAltException(LT(1), getFilename());
1213.            }
1214.            }
1215.            }
1216.            match(LCURLY);
1217.        }
1218.        
1219.        public final void template_head() throws RecognitionException, TokenStreamException {
1220.            
1221.            
1222.            match(LITERAL_template);
1223.            match(LESSTHAN);
1224.            template_parameter_list();
1225.            match(GREATERTHAN);
1226.        }
1227.        
1228.        public final void enum_specifier() throws RecognitionException, TokenStreamException {
1229.            
1230.            Token  id = null;
1231.            
1232.            match(LITERAL_enum);
1233.            {
1234.            switch ( LA(1)) {
1235.            case LCURLY:
1236.            {
1237.                match(LCURLY);
1238.                enumerator_list();
1239.                match(RCURLY);
1240.                break;
1241.            }
1242.            case ID:
1243.            {
1244.                id = LT(1);
1245.                match(ID);
1246.                if ( inputState.guessing==0 ) {
1247.                        if(!symbols.containsKey(id.getText()))
1248.                                        symbols.put(id.getText(),CPPvariables.OT_ENUM);
1249.                                
1250.                }
1251.                {
1252.                switch ( LA(1)) {
1253.                case LCURLY:
1254.                {
1255.                    match(LCURLY);
1256.                    enumerator_list();
1257.                    match(RCURLY);
1258.                    break;
1259.                }
1260.                case LESSTHAN:
1261.                case GREATERTHAN:
1262.                case ID:
1263.                case SEMICOLON:
1264.                case RCURLY:
1265.                case ASSIGNEQUAL:
1266.                case COLON:
1267.                case COMMA:
1268.                case LITERAL__stdcall:
1269.                case LITERAL___stdcall:
1270.                case LPAREN:
1271.                case RPAREN:
1272.                case OPERATOR:
1273.                case LITERAL_this:
1274.                case LITERAL_true:
1275.                case LITERAL_false:
1276.                case STAR:
1277.                case AMPERSAND:
1278.                case LSQUARE:
1279.                case RSQUARE:
1280.                case TILDE:
1281.                case ELLIPSIS:
1282.                case TIMESEQUAL:
1283.                case DIVIDEEQUAL:
1284.                case MINUSEQUAL:
1285.                case PLUSEQUAL:
1286.                case MODEQUAL:
1287.                case SHIFTLEFTEQUAL:
1288.                case SHIFTRIGHTEQUAL:
1289.                case BITWISEANDEQUAL:
1290.                case BITWISEXOREQUAL:
1291.                case BITWISEOREQUAL:
1292.                case QUESTIONMARK:
1293.                case OR:
1294.                case AND:
1295.                case BITWISEOR:
1296.                case BITWISEXOR:
1297.                case NOTEQUAL:
1298.                case EQUAL:
1299.                case LESSTHANOREQUALTO:
1300.                case GREATERTHANOREQUALTO:
1301.                case SHIFTLEFT:
1302.                case SHIFTRIGHT:
1303.                case PLUS:
1304.                case MINUS:
1305.                case DIVIDE:
1306.                case MOD:
1307.                case DOTMBR:
1308.                case POINTERTOMBR:
1309.                case SCOPE:
1310.                case LITERAL__cdecl:
1311.                case LITERAL___cdecl:
1312.                case LITERAL__near:
1313.                case LITERAL___near:
1314.                case LITERAL__far:
1315.                case LITERAL___far:
1316.                case LITERAL___interrupt:
1317.                case LITERAL_pascal:
1318.                case LITERAL__pascal:
1319.                case LITERAL___pascal:
1320.                {
1321.                    break;
1322.                }
1323.                default:
1324.                {
1325.                    throw new NoViableAltException(LT(1), getFilename());
1326.                }
1327.                }
1328.                }
1329.                break;
1330.            }
1331.            default:
1332.            {
1333.                throw new NoViableAltException(LT(1), getFilename());
1334.            }
1335.            }
1336.            }
1337.        }
1338.        
1339.        public final void init_declarator_list() throws RecognitionException, TokenStreamException {
1340.            
1341.            
1342.            init_declarator();
1343.            {
1344.            _loop156:
1345.            do {
1346.                if ((LA(1)==COMMA)) {
1347.                    match(COMMA);
1348.                    init_declarator();
1349.                }
1350.                else {
1351.                    break _loop156;
1352.                }
1353.                
1354.            } while (true);
1355.            }
1356.        }
1357.        
1358.        public final void dtor_head() throws RecognitionException, TokenStreamException {
1359.            
1360.            
1361.            if ( inputState.guessing==0 ) {
1362.                m.beginDtorHead();
1363.            }
1364.            dtor_decl_spec();
1365.            dtor_declarator();
1366.            if ( inputState.guessing==0 ) {
1367.                m.endDtorHead();
1368.            }
1369.        }
1370.        
1371.        public final void dtor_body() throws RecognitionException, TokenStreamException {
1372.            
1373.            
1374.            compound_statement();
1375.        }
1376.        
1377.        public final void ctor_decl_spec() throws RecognitionException, TokenStreamException {
1378.            
1379.            List declSpecs = new ArrayList();
1380.            
1381.            {
1382.            _loop240:
1383.            do {
1384.                switch ( LA(1)) {
1385.                case LITERAL_inline:
1386.                case LITERAL__inline:
1387.                case LITERAL___inline:
1388.                {
1389.                    {
1390.                    switch ( LA(1)) {
1391.                    case LITERAL_inline:
1392.                    {
1393.                        match(LITERAL_inline);
1394.                        break;
1395.                    }
1396.                    case LITERAL__inline:
1397.                    {
1398.                        match(LITERAL__inline);
1399.                        break;
1400.                    }
1401.                    case LITERAL___inline:
1402.                    {
1403.                        match(LITERAL___inline);
1404.                        break;
1405.                    }
1406.                    default:
1407.                    {
1408.                        throw new NoViableAltException(LT(1), getFilename());
1409.                    }
1410.                    }
1411.                    }
1412.                    if ( inputState.guessing==0 ) {
1413.                        declSpecs.add("inline");
1414.                    }
1415.                    break;
1416.                }
1417.                case LITERAL_explicit:
1418.                {
1419.                    match(LITERAL_explicit);
1420.                    if ( inputState.guessing==0 ) {
1421.                        declSpecs.add("explicit");
1422.                    }
1423.                    break;
1424.                }
1425.                default:
1426.                {
1427.                    break _loop240;
1428.                }
1429.                }
1430.            } while (true);
1431.            }
1432.            if ( inputState.guessing==0 ) {
1433.                m.declarationSpecifiers(declSpecs);
1434.            }
1435.        }
1436.        
1437.        public final void ctor_definition() throws RecognitionException, TokenStreamException {
1438.            
1439.            
1440.            if ( inputState.guessing==0 ) {
1441.                m.beginCtorDefinition();
1442.            }
1443.            ctor_head();
1444.            ctor_body();
1445.            if ( inputState.guessing==0 ) {
1446.                m.endCtorDefinition();
1447.            }
1448.        }
1449.        
1450.        public final String  scope_override() throws RecognitionException, TokenStreamException {
1451.            String s="";
1452.            
1453.            Token  id = null;
1454.            
1455.                    String sitem="";
1456.                
1457.            
1458.            {
1459.            switch ( LA(1)) {
1460.            case SCOPE:
1461.            {
1462.                match(SCOPE);
1463.                if ( inputState.guessing==0 ) {
1464.                    sitem=sitem+"::";
1465.                }
1466.                break;
1467.            }
1468.            case ID:
1469.            case OPERATOR:
1470.            case LITERAL_this:
1471.            case LITERAL_true:
1472.            case LITERAL_false:
1473.            case STAR:
1474.            case TILDE:
1475.            {
1476.                break;
1477.            }
1478.            default:
1479.            {
1480.                throw new NoViableAltException(LT(1), getFilename());
1481.            }
1482.            }
1483.            }
1484.            {
1485.            _loop457:
1486.            do {
1487.                if (((LA(1)==ID) && (LA(2)==LESSTHAN||LA(2)==SCOPE))&&(scopedItem(1))) {
1488.                    id = LT(1);
1489.                    match(ID);
1490.                    {
1491.                    switch ( LA(1)) {
1492.                    case LESSTHAN:
1493.                    {
1494.                        match(LESSTHAN);
1495.                        template_argument_list();
1496.                        match(GREATERTHAN);
1497.                        break;
1498.                    }
1499.                    case SCOPE:
1500.                    {
1501.                        break;
1502.                    }
1503.                    default:
1504.                    {
1505.                        throw new NoViableAltException(LT(1), getFilename());
1506.                    }
1507.                    }
1508.                    }
1509.                    match(SCOPE);
1510.                    if ( inputState.guessing==0 ) {
1511.                        
1512.                                        sitem=sitem+id.getText();
1513.                                        sitem=sitem+"::";
1514.                                    
1515.                    }
1516.                }
1517.                else {
1518.                    break _loop457;
1519.                }
1520.                
1521.            } while (true);
1522.            }
1523.            if ( inputState.guessing==0 ) {
1524.                s = sitem;
1525.            }
1526.            return s;
1527.        }
1528.        
1529.        public final void conversion_function_decl_or_def() throws RecognitionException, TokenStreamExcepti...
1530.            
1531.            
1532.            match(OPERATOR);
1533.            declaration_specifiers();
1534.            {
1535.            switch ( LA(1)) {
1536.            case STAR:
1537.            {
1538.                match(STAR);
1539.                break;
1540.            }
1541.            case AMPERSAND:
1542.            {
1543.                match(AMPERSAND);
1544.                break;
1545.            }
1546.            case LESSTHAN:
1547.            case LPAREN:
1548.            {
1549.                break;
1550.            }
1551.            default:
1552.            {
1553.                throw new NoViableAltException(LT(1), getFilename());
1554.            }
1555.            }
1556.            }
1557.            {
1558.            switch ( LA(1)) {
1559.            case LESSTHAN:
1560.            {
1561.                match(LESSTHAN);
1562.                template_parameter_list();
1563.                match(GREATERTHAN);
1564.                break;
1565.            }
1566.            case LPAREN:
1567.            {
1568.                break;
1569.            }
1570.            default:
1571.            {
1572.                throw new NoViableAltException(LT(1), getFilename());
1573.            }
1574.            }
1575.            }
1576.            match(LPAREN);
1577.            {
1578.            switch ( LA(1)) {
1579.            case LITERAL_typedef:
1580.            case LITERAL_enum:
1581.            case ID:
1582.            case LITERAL_inline:
1583.            case LITERAL_extern:
1584.            case LITERAL__inline:
1585.            case LITERAL___inline:
1586.            case LITERAL_virtual:
1587.            case LITERAL_explicit:
1588.            case LITERAL_friend:
1589.            case LITERAL__stdcall:
1590.            case LITERAL___stdcall:
1591.            case LITERAL__declspec:
1592.            case LITERAL___declspec:
1593.            case LPAREN:
1594.            case LITERAL_typename:
1595.            case LITERAL_auto:
1596.            case LITERAL_register:
1597.            case LITERAL_static:
1598.            case LITERAL_mutable:
1599.            case LITERAL_const:
1600.            case LITERAL_const_cast:
1601.            case LITERAL_volatile:
1602.            case LITERAL_char:
1603.            case LITERAL_wchar_t:
1604.            case LITERAL_bool:
1605.            case LITERAL_short:
1606.            case LITERAL_int:
1607.            case 44:
1608.            case 45:
1609.            case 46:
1610.            case LITERAL_long:
1611.            case LITERAL_signed:
1612.            case LITERAL_unsigned:
1613.            case LITERAL_float:
1614.            case LITERAL_double:
1615.            case LITERAL_void:
1616.            case LITERAL_class:
1617.            case LITERAL_struct:
1618.            case LITERAL_union:
1619.            case OPERATOR:
1620.            case LITERAL_this:
1621.            case LITERAL_true:
1622.            case LITERAL_false:
1623.            case STAR:
1624.            case AMPERSAND:
1625.            case TILDE:
1626.            case ELLIPSIS:
1627.            case SCOPE:
1628.            case LITERAL__cdecl:
1629.            case LITERAL___cdecl:
1630.            case LITERAL__near:
1631.            case LITERAL___near:
1632.            case LITERAL__far:
1633.            case LITERAL___far:
1634.            case LITERAL___interrupt:
1635.            case LITERAL_pascal:
1636.            case LITERAL__pascal:
1637.            case LITERAL___pascal:
1638.            {
1639.                parameter_list();
1640.                break;
1641.            }
1642.            case RPAREN:
1643.            {
1644.                break;
1645.            }
1646.            default:
1647.            {
1648.                throw new NoViableAltException(LT(1), getFilename());
1649.            }
1650.            }
1651.            }
1652.            match(RPAREN);
1653.            {
1654.            switch ( LA(1)) {
1655.            case LITERAL_const:
1656.            case LITERAL_const_cast:
1657.            case LITERAL_volatile:
1658.            {
1659.                type_qualifier();
1660.                break;
1661.            }
1662.            case LCURLY:
1663.            case SEMICOLON:
1664.            case LITERAL_throw:
1665.            {
1666.                break;
1667.            }
1668.            default:
1669.            {
1670.                throw new NoViableAltException(LT(1), getFilename());
1671.            }
1672.            }
1673.            }
1674.            {
1675.            switch ( LA(1)) {
1676.            case LITERAL_throw:
1677.            {
1678.                exception_specification();
1679.                break;
1680.            }
1681.            case LCURLY:
1682.            case SEMICOLON:
1683.            {
1684.                break;
1685.            }
1686.            default:
1687.            {
1688.                throw new NoViableAltException(LT(1), getFilename());
1689.            }
1690.            }
1691.            }
1692.            {
1693.            switch ( LA(1)) {
1694.            case LCURLY:
1695.            {
1696.                compound_statement();
1697.                break;
1698.            }
1699.            case SEMICOLON:
1700.            {
1701.                match(SEMICOLON);
1702.                break;
1703.            }
1704.            default:
1705.            {
1706.                throw new NoViableAltException(LT(1), getFilename());
1707.            }
1708.            }
1709.            }
1710.        }
1711.        
1712.        public final void declaration_specifiers() throws RecognitionException, TokenStreamException {
1713.            
1714.            _td=false; boolean td=false; List declSpecs = new ArrayList();
1715.            
1716.            {
1717.            switch ( LA(1)) {
1718.            case LITERAL_typedef:
1719.            case LITERAL_enum:
1720.            case ID:
1721.            case LITERAL_inline:
1722.            case LITERAL_extern:
1723.            case LITERAL__inline:
1724.            case LITERAL___inline:
1725.            case LITERAL_virtual:
1726.            case LITERAL_explicit:
1727.            case LITERAL_friend:
1728.            case LITERAL__stdcall:
1729.            case LITERAL___stdcall:
1730.            case LITERAL__declspec:
1731.            case LITERAL___declspec:
1732.            case LITERAL_auto:
1733.            case LITERAL_register:
1734.            case LITERAL_static:
1735.            case LITERAL_mutable:
1736.            case LITERAL_const:
1737.            case LITERAL_const_cast:
1738.            case LITERAL_volatile:
1739.            case LITERAL_char:
1740.            case LITERAL_wchar_t:
1741.            case LITERAL_bool:
1742.            case LITERAL_short:
1743.            case LITERAL_int:
1744.            case 44:
1745.            case 45:
1746.            case 46:
1747.            case LITERAL_long:
1748.            case LITERAL_signed:
1749.            case LITERAL_unsigned:
1750.            case LITERAL_float:
1751.            case LITERAL_double:
1752.            case LITERAL_void:
1753.            case LITERAL_class:
1754.            case LITERAL_struct:
1755.            case LITERAL_union:
1756.            case SCOPE:
1757.            {
1758.                {
1759.                _loop119:
1760.                do {
1761.                    switch ( LA(1)) {
1762.                    case LITERAL_extern:
1763.                    case LITERAL_auto:
1764.                    case LITERAL_register:
1765.                    case LITERAL_static:
1766.                    case LITERAL_mutable:
1767.                    {
1768.                        storage_class_specifier();
1769.                        break;
1770.                    }
1771.                    case LITERAL_const:
1772.                    case LITERAL_const_cast:
1773.                    case LITERAL_volatile:
1774.                    {
1775.                        type_qualifier();
1776.                        break;
1777.                    }
1778.                    case LITERAL_inline:
1779.                    case LITERAL__inline:
1780.                    case LITERAL___inline:
1781.                    {
1782.                        {
1783.                        switch ( LA(1)) {
1784.                        case LITERAL_inline:
1785.                        {
1786.                            match(LITERAL_inline);
1787.                            break;
1788.                        }
1789.                        case LITERAL__inline:
1790.                        {
1791.                            match(LITERAL__inline);
1792.                            break;
1793.                        }
1794.                        case LITERAL___inline:
1795.                        {
1796.                            match(LITERAL___inline);
1797.                            break;
1798.                        }
1799.                        default:
1800.                        {
1801.                            throw new NoViableAltException(LT(1), getFilename());
1802.                        }
1803.                        }
1804.                        }
1805.                        if ( inputState.guessing==0 ) {
1806.                            declSpecs.add("inline");
1807.                        }
1808.                        break;
1809.                    }
1810.                    case LITERAL_virtual:
1811.                    {
1812.                        match(LITERAL_virtual);
1813.                        if ( inputState.guessing==0 ) {
1814.                            declSpecs.add("virtual");
1815.                        }
1816.                        break;
1817.                    }
1818.                    case LITERAL_explicit:
1819.                    {
1820.                        match(LITERAL_explicit);
1821.                        if ( inputState.guessing==0 ) {
1822.                            declSpecs.add("explicit");
1823.                        }
1824.                        break;
1825.                    }
1826.                    case LITERAL_typedef:
1827.                    {
1828.                        match(LITERAL_typedef);
1829.                        if ( inputState.guessing==0 ) {
1830.                            td=true; declSpecs.add("typedef");
1831.                        }
1832.                        break;
1833.                    }
1834.                    case LITERAL_friend:
1835.                    {
1836.                        match(LITERAL_friend);
1837.                        if ( inputState.guessing==0 ) {
1838.                            declSpecs.add("friend");
1839.                        }
1840.                        break;
1841.                    }
1842.                    case LITERAL__stdcall:
1843.                    case LITERAL___stdcall:
1844.                    {
1845.                        {
1846.                        switch ( LA(1)) {
1847.                        case LITERAL__stdcall:
1848.                        {
1849.                            match(LITERAL__stdcall);
1850.                            break;
1851.                        }
1852.                        case LITERAL___stdcall:
1853.                        {
1854.                            match(LITERAL___stdcall);
1855.                            break;
1856.                        }
1857.                        default:
1858.                        {
1859.                            throw new NoViableAltException(LT(1), getFilename());
1860.                        }
1861.                        }
1862.                        }
1863.                        if ( inputState.guessing==0 ) {
1864.                            declSpecs.add("__stdcall");
1865.                        }
1866.                        break;
1867.                    }
1868.                    default:
1869.                        if ((LA(1)==LITERAL__declspec||LA(1)==LITERAL___declspec) && (LA(2)==LPAREN)) {
1870.                            {
1871.                            switch ( LA(1)) {
1872.                            case LITERAL__declspec:
1873.                            {
1874.                                match(LITERAL__declspec);
1875.                                break;
1876.                            }
1877.                            case LITERAL___declspec:
1878.                            {
1879.                                match(LITERAL___declspec);
1880.                                break;
1881.                            }
1882.                            default:
1883.                            {
1884.                                throw new NoViableAltException(LT(1), getFilename());
1885.                            }
1886.                            }
1887.                            }
1888.                            match(LPAREN);
1889.                            match(ID);
1890.                            match(RPAREN);
1891.                        }
1892.                    else {
1893.                        break _loop119;
1894.                    }
1895.                    }
1896.                } while (true);
1897.                }
1898.                if ( inputState.guessing==0 ) {
1899.                    if (!declSpecs.isEmpty()) m.declarationSpecifiers(declSpecs);
1900.                }
1901.                type_specifier();
1902.                break;
1903.            }
1904.            case LITERAL_typename:
1905.            {
1906.                match(LITERAL_typename);
1907.                if ( inputState.guessing==0 ) {
1908.                    td=true;
1909.                }
1910.                direct_declarator();
1911.                break;
1912.            }
1913.            default:
1914.            {
1915.                throw new NoViableAltException(LT(1), getFilename());
1916.            }
1917.            }
1918.            }
1919.            if ( inputState.guessing==0 ) {
1920.                _td=td;
1921.            }
1922.        }
1923.        
1924.        public final void function_declarator() throws RecognitionException, TokenStreamException {
1925.            
1926.            
1927.            boolean synPredMatched227 = false;
1928.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
1929.                int _m227 = mark();
1930.                synPredMatched227 = true;
1931.                inputState.guessing++;
1932.                try {
1933.                    {
1934.                    ptr_operator();
1935.                    }
1936.                }
1937.                catch (RecognitionException pe) {
1938.                    synPredMatched227 = false;
1939.                }
1940.                rewind(_m227);
1941.    inputState.guessing--;
1942.            }
1943.            if ( synPredMatched227 ) {
1944.                ptr_operator();
1945.                function_declarator();
1946.            }
1947.            else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
1948.                function_direct_declarator();
1949.            }
1950.            else {
1951.                throw new NoViableAltException(LT(1), getFilename());
1952.            }
1953.            
1954.        }
1955.        
1956.        public final void function_definition() throws RecognitionException, TokenStreamException {
1957.            
1958.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
1959.            
1960.            {
1961.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
1962.                declaration_specifiers();
1963.                function_declarator();
1964.                {
1965.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1966.                    {
1967.                    _loop100:
1968.                    do {
1969.                        if ((_tokenSet_1.member(LA(1)))) {
1970.                            declaration();
1971.                        }
1972.                        else {
1973.                            break _loop100;
1974.                        }
1975.                        
1976.                    } while (true);
1977.                    }
1978.                }
1979.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
1980.                }
1981.                else {
1982.                    throw new NoViableAltException(LT(1), getFilename());
1983.                }
1984.                
1985.                }
1986.                compound_statement();
1987.            }
1988.            else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
1989.                function_declarator();
1990.                {
1991.                if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
1992.                    {
1993.                    _loop103:
1994.                    do {
1995.                        if ((_tokenSet_1.member(LA(1)))) {
1996.                            declaration();
1997.                        }
1998.                        else {
1999.                            break _loop103;
2000.                        }
2001.                        
2002.                    } while (true);
2003.                    }
2004.                }
2005.                else if ((LA(1)==LCURLY) && (_tokenSet_20.member(LA(2)))) {
2006.                }
2007.                else {
2008.                    throw new NoViableAltException(LT(1), getFilename());
2009.                }
2010.                
2011.                }
2012.                compound_statement();
2013.            }
2014.            else {
2015.                throw new NoViableAltException(LT(1), getFilename());
2016.            }
2017.            
2018.            }
2019.        }
2020.        
2021.        public final void decl_namespace() throws RecognitionException, TokenStreamException {
2022.            
2023.            Token  ns = null;
2024.            Token  ns2 = null;
2025.            String qid="";
2026.            
2027.            match(LITERAL_namespace);
2028.            {
2029.            if ((LA(1)==ID||LA(1)==LCURLY) && (_tokenSet_23.member(LA(2)))) {
2030.                {
2031.                switch ( LA(1)) {
2032.                case ID:
2033.                {
2034.                    ns = LT(1);
2035.                    match(ID);
2036.                    if ( inputState.guessing==0 ) {
2037.                            _td = true;declaratorID(ns.getText(),CPPvariables.QI_TYPE);
2038.                    }
2039.                    break;
2040.                }
2041.                case LCURLY:
2042.                {
2043.                    break;
2044.                }
2045.                default:
2046.                {
2047.                    throw new NoViableAltException(LT(1), getFilename());
2048.                }
2049.                }
2050.                }
2051.                match(LCURLY);
2052.                if ( inputState.guessing==0 ) {
2053.                    m.enterNamespaceScope(ns.getText());
2054.                }
2055.                {
2056.                _loop49:
2057.                do {
2058.                    if ((_tokenSet_0.member(LA(1)))) {
2059.                        external_declaration();
2060.                    }
2061.                    else {
2062.                        break _loop49;
2063.                    }
2064.                    
2065.                } while (true);
2066.                }
2067.                if ( inputState.guessing==0 ) {
2068.                    m.exitNamespaceScope();
2069.                }
2070.                match(RCURLY);
2071.            }
2072.            else if ((LA(1)==ID) && (LA(2)==ASSIGNEQUAL)) {
2073.                ns2 = LT(1);
2074.                match(ID);
2075.                if ( inputState.guessing==0 ) {
2076.                    _td=true;declaratorID(ns2.getText(),CPPvariables.QI_TYPE);
2077.                }
2078.                match(ASSIGNEQUAL);
2079.                qid=qualified_id();
2080.                match(SEMICOLON);
2081.                if ( inputState.guessing==0 ) {
2082.                    m.makeNamespaceAlias(qid, ns2.getText());
2083.                }
2084.            }
2085.            else {
2086.                throw new NoViableAltException(LT(1), getFilename());
2087.            }
2088.            
2089.            }
2090.        }
2091.        
2092.        public final String  qualified_id() throws RecognitionException, TokenStreamException {
2093.            String q="";
2094.            
2095.            Token  id = null;
2096.            
2097.                String so="";
2098.                String qitem="";
2099.                
2100.            
2101.            so=scope_override();
2102.            if ( inputState.guessing==0 ) {
2103.                qitem=so;
2104.            }
2105.            {
2106.            switch ( LA(1)) {
2107.            case ID:
2108.            {
2109.                id = LT(1);
2110.                match(ID);
2111.                {
2112.                if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
2113.                    match(LESSTHAN);
2114.                    template_argument_list();
2115.                    match(GREATERTHAN);
2116.                }
2117.                else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
2118.                }
2119.                else {
2120.                    throw new NoViableAltException(LT(1), getFilename());
2121.                }
2122.                
2123.                }
2124.                if ( inputState.guessing==0 ) {
2125.                    
2126.                            qitem=qitem+id.getText();
2127.                        
2128.                }
2129.                break;
2130.            }
2131.            case OPERATOR:
2132.            {
2133.                match(OPERATOR);
2134.                optor();
2135.                if ( inputState.guessing==0 ) {
2136.                    qitem=qitem+"operator"+"NYI";
2137.                }
2138.                break;
2139.            }
2140.            case LITERAL_this:
2141.            {
2142.                match(LITERAL_this);
2143.                break;
2144.            }
2145.            case LITERAL_true:
2146.            case LITERAL_false:
2147.            {
2148.                {
2149.                switch ( LA(1)) {
2150.                case LITERAL_true:
2151.                {
2152.                    match(LITERAL_true);
2153.                    break;
2154.                }
2155.                case LITERAL_false:
2156.                {
2157.                    match(LITERAL_false);
2158.                    break;
2159.                }
2160.                default:
2161.                {
2162.                    throw new NoViableAltException(LT(1), getFilename());
2163.                }
2164.                }
2165.                }
2166.                break;
2167.            }
2168.            default:
2169.            {
2170.                throw new NoViableAltException(LT(1), getFilename());
2171.            }
2172.            }
2173.            }
2174.            if ( inputState.guessing==0 ) {
2175.                q = qitem;
2176.            }
2177.            return q;
2178.        }
2179.        
2180.        public final void member_declaration() throws RecognitionException, TokenStreamException {
2181.            
2182.            String q="";
2183.            
2184.            if ( inputState.guessing==0 ) {
2185.                m.beginMemberDeclaration();
2186.            }
2187.            {
2188.            switch ( LA(1)) {
2189.            case LITERAL_public:
2190.            case LITERAL_protected:
2191.            case LITERAL_private:
2192.            {
2193.                access_specifier();
2194.                match(COLON);
2195.                break;
2196.            }
2197.            case SEMICOLON:
2198.            {
2199.                match(SEMICOLON);
2200.                break;
2201.            }
2202.            default:
2203.                boolean synPredMatched54 = false;
2204.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2205.                    int _m54 = mark();
2206.                    synPredMatched54 = true;
2207.                    inputState.guessing++;
2208.                    try {
2209.                        {
2210.                        {
2211.                        switch ( LA(1)) {
2212.                        case LITERAL_typedef:
2213.                        {
2214.                            match(LITERAL_typedef);
2215.                            break;
2216.                        }
2217.                        case LITERAL_class:
2218.                        case LITERAL_struct:
2219.                        case LITERAL_union:
2220.                        {
2221.                            break;
2222.                        }
2223.                        default:
2224.                        {
2225.                            throw new NoViableAltException(LT(1), getFilename());
2226.                        }
2227.                        }
2228.                        }
2229.                        class_head();
2230.                        }
2231.                    }
2232.                    catch (RecognitionException pe) {
2233.                        synPredMatched54 = false;
2234.                    }
2235.                    rewind(_m54);
2236.    inputState.guessing--;
2237.                }
2238.                if ( synPredMatched54 ) {
2239.                    declaration();
2240.                }
2241.                else {
2242.                    boolean synPredMatched57 = false;
2243.                    if (((LA(1)==LITERAL_enum) && (LA(2)==ID||LA(2)==LCURLY))) {
2244.                        int _m57 = mark();
2245.                        synPredMatched57 = true;
2246.                        inputState.guessing++;
2247.                        try {
2248.                            {
2249.                            match(LITERAL_enum);
2250.                            {
2251.                            switch ( LA(1)) {
2252.                            case ID:
2253.                            {
2254.                                match(ID);
2255.                                break;
2256.                            }
2257.                            case LCURLY:
2258.                            {
2259.                                break;
2260.                            }
2261.                            default:
2262.                            {
2263.                                throw new NoViableAltException(LT(1), getFilename());
2264.                            }
2265.                            }
2266.                            }
2267.                            match(LCURLY);
2268.                            }
2269.                        }
2270.                        catch (RecognitionException pe) {
2271.                            synPredMatched57 = false;
2272.                        }
2273.                        rewind(_m57);
2274.    inputState.guessing--;
2275.                    }
2276.                    if ( synPredMatched57 ) {
2277.                        enum_specifier();
2278.                        {
2279.                        switch ( LA(1)) {
2280.                        case ID:
2281.                        case COLON:
2282.                        case LITERAL__stdcall:
2283.                        case LITERAL___stdcall:
2284.                        case LPAREN:
2285.                        case OPERATOR:
2286.                        case LITERAL_this:
2287.                        case LITERAL_true:
2288.                        case LITERAL_false:
2289.                        case STAR:
2290.                        case AMPERSAND:
2291.                        case TILDE:
2292.                        case SCOPE:
2293.                        case LITERAL__cdecl:
2294.                        case LITERAL___cdecl:
2295.                        case LITERAL__near:
2296.                        case LITERAL___near:
2297.                        case LITERAL__far:
2298.                        case LITERAL___far:
2299.                        case LITERAL___interrupt:
2300.                        case LITERAL_pascal:
2301.                        case LITERAL__pascal:
2302.                        case LITERAL___pascal:
2303.                        {
2304.                            member_declarator_list();
2305.                            break;
2306.                        }
2307.                        case SEMICOLON:
2308.                        {
2309.                            break;
2310.                        }
2311.                        default:
2312.                        {
2313.                            throw new NoViableAltException(LT(1), getFilename());
2314.                        }
2315.                        }
2316.                        }
2317.                        match(SEMICOLON);
2318.                    }
2319.                    else {
2320.                        boolean synPredMatched60 = false;
2321.                        if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2322.                            int _m60 = mark();
2323.                            synPredMatched60 = true;
2324.                            inputState.guessing++;
2325.                            try {
2326.                                {
2327.                                template_head();
2328.                                class_head();
2329.                                }
2330.                            }
2331.                            catch (RecognitionException pe) {
2332.                                synPredMatched60 = false;
2333.                            }
2334.                            rewind(_m60);
2335.    inputState.guessing--;
2336.                        }
2337.                        if ( synPredMatched60 ) {
2338.                            template_head();
2339.                            declaration();
2340.                        }
2341.                        else {
2342.                            boolean synPredMatched62 = false;
2343.                            if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2344.                                int _m62 = mark();
2345.                                synPredMatched62 = true;
2346.                                inputState.guessing++;
2347.                                try {
2348.                                    {
2349.                                    ctor_decl_spec();
2350.                                    if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2351.                                      throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2352.                                    ctor_declarator();
2353.                                    match(SEMICOLON);
2354.                                    }
2355.                                }
2356.                                catch (RecognitionException pe) {
2357.                                    synPredMatched62 = false;
2358.                                }
2359.                                rewind(_m62);
2360.    inputState.guessing--;
2361.                            }
2362.                            if ( synPredMatched62 ) {
2363.                                ctor_decl_spec();
2364.                                ctor_declarator();
2365.                                match(SEMICOLON);
2366.                            }
2367.                            else {
2368.                                boolean synPredMatched65 = false;
2369.                                if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2370.                                    int _m65 = mark();
2371.                                    synPredMatched65 = true;
2372.                                    inputState.guessing++;
2373.                                    try {
2374.                                        {
2375.                                        ctor_decl_spec();
2376.                                        if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2377.                                          throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2378.                                        ctor_declarator();
2379.                                        {
2380.                                        switch ( LA(1)) {
2381.                                        case COLON:
2382.                                        {
2383.                                            match(COLON);
2384.                                            break;
2385.                                        }
2386.                                        case LCURLY:
2387.                                        {
2388.                                            match(LCURLY);
2389.                                            break;
2390.                                        }
2391.                                        default:
2392.                                        {
2393.                                            throw new NoViableAltException(LT(1), getFilename());
2394.                                        }
2395.                                        }
2396.                                        }
2397.                                        }
2398.                                    }
2399.                                    catch (RecognitionException pe) {
2400.                                        synPredMatched65 = false;
2401.                                    }
2402.                                    rewind(_m65);
2403.    inputState.guessing--;
2404.                                }
2405.                                if ( synPredMatched65 ) {
2406.                                    ctor_definition();
2407.                                }
2408.                                else {
2409.                                    boolean synPredMatched67 = false;
2410.                                    if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2411.                                        int _m67 = mark();
2412.                                        synPredMatched67 = true;
2413.                                        inputState.guessing++;
2414.                                        try {
2415.                                            {
2416.                                            dtor_head();
2417.                                            match(SEMICOLON);
2418.                                            }
2419.                                        }
2420.                                        catch (RecognitionException pe) {
2421.                                            synPredMatched67 = false;
2422.                                        }
2423.                                        rewind(_m67);
2424.    inputState.guessing--;
2425.                                    }
2426.                                    if ( synPredMatched67 ) {
2427.                                        dtor_head();
2428.                                        match(SEMICOLON);
2429.                                    }
2430.                                    else {
2431.                                        boolean synPredMatched69 = false;
2432.                                        if (((_tokenSet_27.member(LA(1))) && (_tokenSet_4.member(LA(2))))) {
2433.                                            int _m69 = mark();
2434.                                            synPredMatched69 = true;
2435.                                            inputState.guessing++;
2436.                                            try {
2437.                                                {
2438.                                                dtor_head();
2439.                                                match(LCURLY);
2440.                                                }
2441.                                            }
2442.                                            catch (RecognitionException pe) {
2443.                                                synPredMatched69 = false;
2444.                                            }
2445.                                            rewind(_m69);
2446.    inputState.guessing--;
2447.                                        }
2448.                                        if ( synPredMatched69 ) {
2449.                                            dtor_head();
2450.                                            dtor_body();
2451.                                        }
2452.                                        else {
2453.                                            boolean synPredMatched71 = false;
2454.                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2455.                                                int _m71 = mark();
2456.                                                synPredMatched71 = true;
2457.                                                inputState.guessing++;
2458.                                                try {
2459.                                                    {
2460.                                                    declaration_specifiers();
2461.                                                    function_declarator();
2462.                                                    match(SEMICOLON);
2463.                                                    }
2464.                                                }
2465.                                                catch (RecognitionException pe) {
2466.                                                    synPredMatched71 = false;
2467.                                                }
2468.                                                rewind(_m71);
2469.    inputState.guessing--;
2470.                                            }
2471.                                            if ( synPredMatched71 ) {
2472.                                                if ( inputState.guessing==0 ) {
2473.                                                    m.beginFunctionDeclaration();
2474.                                                }
2475.                                                declaration();
2476.                                                if ( inputState.guessing==0 ) {
2477.                                                    m.endFunctionDeclaration();
2478.                                                }
2479.                                            }
2480.                                            else {
2481.                                                boolean synPredMatched73 = false;
2482.                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2483.                                                    int _m73 = mark();
2484.                                                    synPredMatched73 = true;
2485.                                                    inputState.guessing++;
2486.                                                    try {
2487.                                                        {
2488.                                                        declaration_specifiers();
2489.                                                        function_declarator();
2490.                                                        match(LCURLY);
2491.                                                        }
2492.                                                    }
2493.                                                    catch (RecognitionException pe) {
2494.                                                        synPredMatched73 = false;
2495.                                                    }
2496.                                                    rewind(_m73);
2497.    inputState.guessing--;
2498.                                                }
2499.                                                if ( synPredMatched73 ) {
2500.                                                    if ( inputState.guessing==0 ) {
2501.                                                        m.beginFunctionDefinition();
2502.                                                    }
2503.                                                    function_definition();
2504.                                                    if ( inputState.guessing==0 ) {
2505.                                                        m.endFunctionDefinition();
2506.                                                    }
2507.                                                }
2508.                                                else {
2509.                                                    boolean synPredMatched76 = false;
2510.                                                    if (((LA(1)==LITERAL_inline||LA(1)==OPERATOR) && (_tokenSet_28.member(LA(2))))) {
2511.                                                        int _m76 = mark();
2512.                                                        synPredMatched76 = true;
2513.                                                        inputState.guessing++;
2514.                                                        try {
2515.                                                            {
2516.                                                            {
2517.                                                            switch ( LA(1)) {
2518.                                                            case LITERAL_inline:
2519.                                                            {
2520.                                                                match(LITERAL_inline);
2521.                                                                break;
2522.                                                            }
2523.                                                            case OPERATOR:
2524.                                                            {
2525.                                                                break;
2526.                                                            }
2527.                                                            default:
2528.                                                            {
2529.                                                                throw new NoViableAltException(LT(1), getFilename());
2530.                                                            }
2531.                                                            }
2532.                                                            }
2533.                                                            conversion_function_decl_or_def();
2534.                                                            }
2535.                                                        }
2536.                                                        catch (RecognitionException pe) {
2537.                                                            synPredMatched76 = false;
2538.                                                        }
2539.                                                        rewind(_m76);
2540.    inputState.guessing--;
2541.                                                    }
2542.                                                    if ( synPredMatched76 ) {
2543.                                                        {
2544.                                                        switch ( LA(1)) {
2545.                                                        case LITERAL_inline:
2546.                                                        {
2547.                                                            match(LITERAL_inline);
2548.                                                            break;
2549.                                                        }
2550.                                                        case OPERATOR:
2551.                                                        {
2552.                                                            break;
2553.                                                        }
2554.                                                        default:
2555.                                                        {
2556.                                                            throw new NoViableAltException(LT(1), getFilename());
2557.                                                        }
2558.                                                        }
2559.                                                        }
2560.                                                        conversion_function_decl_or_def();
2561.                                                    }
2562.                                                    else {
2563.                                                        boolean synPredMatched79 = false;
2564.                                                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
2565.                                                            int _m79 = mark();
2566.                                                            synPredMatched79 = true;
2567.                                                            inputState.guessing++;
2568.                                                            try {
2569.                                                                {
2570.                                                                qualified_id();
2571.                                                                match(SEMICOLON);
2572.                                                                }
2573.                                                            }
2574.                                                            catch (RecognitionException pe) {
2575.                                                                synPredMatched79 = false;
2576.                                                            }
2577.                                                            rewind(_m79);
2578.    inputState.guessing--;
2579.                                                        }
2580.                                                        if ( synPredMatched79 ) {
2581.                                                            q=qualified_id();
2582.                                                            match(SEMICOLON);
2583.                                                        }
2584.                                                        else {
2585.                                                            boolean synPredMatched81 = false;
2586.                                                            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
2587.                                                                int _m81 = mark();
2588.                                                                synPredMatched81 = true;
2589.                                                                inputState.guessing++;
2590.                                                                try {
2591.                                                                    {
2592.                                                                    declaration_specifiers();
2593.                                                                    }
2594.                                                                }
2595.                                                                catch (RecognitionException pe) {
2596.                                                                    synPredMatched81 = false;
2597.                                                                }
2598.                                                                rewind(_m81);
2599.    inputState.guessing--;
2600.                                                            }
2601.                                                            if ( synPredMatched81 ) {
2602.                                                                declaration_specifiers();
2603.                                                                {
2604.                                                                switch ( LA(1)) {
2605.                                                                case ID:
2606.                                                                case COLON:
2607.                                                                case LITERAL__stdcall:
2608.                                                                case LITERAL___stdcall:
2609.                                                                case LPAREN:
2610.                                                                case OPERATOR:
2611.                                                                case LITERAL_this:
2612.                                                                case LITERAL_true:
2613.                                                                case LITERAL_false:
2614.                                                                case STAR:
2615.                                                                case AMPERSAND:
2616.                                                                case TILDE:
2617.                                                                case SCOPE:
2618.                                                                case LITERAL__cdecl:
2619.                                                                case LITERAL___cdecl:
2620.                                                                case LITERAL__near:
2621.                                                                case LITERAL___near:
2622.                                                                case LITERAL__far:
2623.                                                                case LITERAL___far:
2624.                                                                case LITERAL___interrupt:
2625.                                                                case LITERAL_pascal:
2626.                                                                case LITERAL__pascal:
2627.                                                                case LITERAL___pascal:
2628.                                                                {
2629.                                                                    member_declarator_list();
2630.                                                                    break;
2631.                                                                }
2632.                                                                case SEMICOLON:
2633.                                                                {
2634.                                                                    break;
2635.                                                                }
2636.                                                                default:
2637.                                                                {
2638.                                                                    throw new NoViableAltException(LT(1), getFilename());
2639.                                                                }
2640.                                                                }
2641.                                                                }
2642.                                                                match(SEMICOLON);
2643.                                                            }
2644.                                                            else {
2645.                                                                boolean synPredMatched84 = false;
2646.                                                                if (((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2))))) {
2647.                                                                    int _m84 = mark();
2648.                                                                    synPredMatched84 = true;
2649.                                                                    inputState.guessing++;
2650.                                                                    try {
2651.                                                                        {
2652.                                                                        function_declarator();
2653.                                                                        match(SEMICOLON);
2654.                                                                        }
2655.                                                                    }
2656.                                                                    catch (RecognitionException pe) {
2657.                                                                        synPredMatched84 = false;
2658.                                                                    }
2659.                                                                    rewind(_m84);
2660.    inputState.guessing--;
2661.                                                                }
2662.                                                                if ( synPredMatched84 ) {
2663.                                                                    function_declarator();
2664.                                                                    match(SEMICOLON);
2665.                                                                }
2666.                                                                else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
2667.                                                                    function_declarator();
2668.                                                                    compound_statement();
2669.                                                                }
2670.                                                                else {
2671.                                                                    boolean synPredMatched87 = false;
2672.                                                                    if (((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN))) {
2673.                                                                        int _m87 = mark();
2674.                                                                        synPredMatched87 = true;
2675.                                                                        inputState.guessing++;
2676.                                                                        try {
2677.                                                                            {
2678.                                                                            template_head();
2679.                                                                            declaration_specifiers();
2680.                                                                            {
2681.                                                                            switch ( LA(1)) {
2682.                                                                            case ID:
2683.                                                                            case LITERAL__stdcall:
2684.                                                                            case LITERAL___stdcall:
2685.                                                                            case LPAREN:
2686.                                                                            case OPERATOR:
2687.                                                                            case LITERAL_this:
2688.                                                                            case LITERAL_true:
2689.                                                                            case LITERAL_false:
2690.                                                                            case STAR:
2691.                                                                            case AMPERSAND:
2692.                                                                            case TILDE:
2693.                                                                            case SCOPE:
2694.                                                                            case LITERAL__cdecl:
2695.                                                                            case LITERAL___cdecl:
2696.                                                                            case LITERAL__near:
2697.                                                                            case LITERAL___near:
2698.                                                                            case LITERAL__far:
2699.                                                                            case LITERAL___far:
2700.                                                                            case LITERAL___interrupt:
2701.                                                                            case LITERAL_pascal:
2702.                                                                            case LITERAL__pascal:
2703.                                                                            case LITERAL___pascal:
2704.                                                                            {
2705.                                                                                init_declarator_list();
2706.                                                                                break;
2707.                                                                            }
2708.                                                                            case SEMICOLON:
2709.                                                                            {
2710.                                                                                break;
2711.                                                                            }
2712.                                                                            default:
2713.                                                                            {
2714.                                                                                throw new NoViableAltException(LT(1), getFilename());
2715.                                                                            }
2716.                                                                            }
2717.                                                                            }
2718.                                                                            match(SEMICOLON);
2719.                                                                            }
2720.                                                                        }
2721.                                                                        catch (RecognitionException pe) {
2722.                                                                            synPredMatched87 = false;
2723.                                                                        }
2724.                                                                        rewind(_m87);
2725.    inputState.guessing--;
2726.                                                                    }
2727.                                                                    if ( synPredMatched87 ) {
2728.                                                                        template_head();
2729.                                                                        declaration_specifiers();
2730.                                                                        {
2731.                                                                        switch ( LA(1)) {
2732.                                                                        case ID:
2733.                                                                        case LITERAL__stdcall:
2734.                                                                        case LITERAL___stdcall:
2735.                                                                        case LPAREN:
2736.                                                                        case OPERATOR:
2737.                                                                        case LITERAL_this:
2738.                                                                        case LITERAL_true:
2739.                                                                        case LITERAL_false:
2740.                                                                        case STAR:
2741.                                                                        case AMPERSAND:
2742.                                                                        case TILDE:
2743.                                                                        case SCOPE:
2744.                                                                        case LITERAL__cdecl:
2745.                                                                        case LITERAL___cdecl:
2746.                                                                        case LITERAL__near:
2747.                                                                        case LITERAL___near:
2748.                                                                        case LITERAL__far:
2749.                                                                        case LITERAL___far:
2750.                                                                        case LITERAL___interrupt:
2751.                                                                        case LITERAL_pascal:
2752.                                                                        case LITERAL__pascal:
2753.                                                                        case LITERAL___pascal:
2754.                                                                        {
2755.                                                                            init_declarator_list();
2756.                                                                            break;
2757.                                                                        }
2758.                                                                        case SEMICOLON:
2759.                                                                        {
2760.                                                                            break;
2761.                                                                        }
2762.                                                                        default:
2763.                                                                        {
2764.                                                                            throw new NoViableAltException(LT(1), getFilename());
2765.                                                                        }
2766.                                                                        }
2767.                                                                        }
2768.                                                                        match(SEMICOLON);
2769.                                                                    }
2770.                                                                    else if ((LA(1)==LITERAL_template) && (LA(2)==LESSTHAN)) {
2771.                                                                        template_head();
2772.                                                                        {
2773.                                                                        boolean synPredMatched91 = false;
2774.                                                                        if (((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2))))) {
2775.                                                                            int _m91 = mark();
2776.                                                                            synPredMatched91 = true;
2777.                                                                            inputState.guessing++;
2778.                                                                            try {
2779.                                                                                {
2780.                                                                                ctor_decl_spec();
2781.                                                                                if (!(qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)))
2782.                                                                                  throw new SemanticException("qualifiedItemIsOneOf(CPPvariables.QI_CTOR,0)");
2783.                                                                                }
2784.                                                                            }
2785.                                                                            catch (RecognitionException pe) {
2786.                                                                                synPredMatched91 = false;
2787.                                                                            }
2788.                                                                            rewind(_m91);
2789.    inputState.guessing--;
2790.                                                                        }
2791.                                                                        if ( synPredMatched91 ) {
2792.                                                                            ctor_definition();
2793.                                                                        }
2794.                                                                        else {
2795.                                                                            boolean synPredMatched93 = false;
2796.                                                                            if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
2797.                                                                                int _m93 = mark();
2798.                                                                                synPredMatched93 = true;
2799.                                                                                inputState.guessing++;
2800.                                                                                try {
2801.                                                                                    {
2802.                                                                                    declaration_specifiers();
2803.                                                                                    function_declarator();
2804.                                                                                    match(SEMICOLON);
2805.                                                                                    }
2806.                                                                                }
2807.                                                                                catch (RecognitionException pe) {
2808.                                                                                    synPredMatched93 = false;
2809.                                                                                }
2810.                                                                                rewind(_m93);
2811.    inputState.guessing--;
2812.                                                                            }
2813.                                                                            if ( synPredMatched93 ) {
2814.                                                                                declaration();
2815.                                                                            }
2816.                                                                            else {
2817.                                                                                boolean synPredMatched95 = false;
2818.                                                                                if (((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2))))) {
2819.                                                                                    int _m95 = mark();
2820.                                                                                    synPredMatched95 = true;
2821.                                                                                    inputState.guessing++;
2822.                                                                                    try {
2823.                                                                                        {
2824.                                                                                        declaration_specifiers();
2825.                                                                                        function_declarator();
2826.                                                                                        match(LCURLY);
2827.                                                                                        }
2828.                                                                                    }
2829.                                                                                    catch (RecognitionException pe) {
2830.                                                                                        synPredMatched95 = false;
2831.                                                                                    }
2832.                                                                                    rewind(_m95);
2833.    inputState.guessing--;
2834.                                                                                }
2835.                                                                                if ( synPredMatched95 ) {
2836.                                                                                    function_definition();
2837.                                                                                }
2838.                                                                                else if ((LA(1)==OPERATOR) && (_tokenSet_11.member(LA(2)))) {
2839.                                                                                    conversion_function_decl_or_def();
2840.                                                                                }
2841.                                                                                else {
2842.                                                                                    throw new NoViableAltException(LT(1), getFilename());
2843.                                                                                }
2844.                                                                                }}
2845.                                                                                }
2846.                                                                            }
2847.                                                                        else {
2848.                                                                            throw new NoViableAltException(LT(1), getFilename());
2849.                                                                        }
2850.                                                                        }}}}}}}}}}}}}}
2851.                                                                        }
2852.                                                                        if ( inputState.guessing==0 ) {
2853.                                                                            m.endMemberDeclaration();
2854.                                                                        }
2855.                                                                    }
2856.                                                                    
2857.        public final void member_declarator_list() throws RecognitionException, TokenStreamException {
2858.            
2859.            m.beginMemberDeclaratorList();
2860.            
2861.            {
2862.            member_declarator();
2863.            {
2864.            switch ( LA(1)) {
2865.            case ASSIGNEQUAL:
2866.            {
2867.                match(ASSIGNEQUAL);
2868.                match(OCTALINT);
2869.                break;
2870.            }
2871.            case SEMICOLON:
2872.            case COMMA:
2873.            {
2874.                break;
2875.            }
2876.            default:
2877.            {
2878.                throw new NoViableAltException(LT(1), getFilename());
2879.            }
2880.            }
2881.            }
2882.            {
2883.            _loop180:
2884.            do {
2885.                if ((LA(1)==COMMA)) {
2886.                    match(COMMA);
2887.                    member_declarator();
2888.                    {
2889.                    switch ( LA(1)) {
2890.                    case ASSIGNEQUAL:
2891.                    {
2892.                        match(ASSIGNEQUAL);
2893.                        match(OCTALINT);
2894.                        break;
2895.                    }
2896.                    case SEMICOLON:
2897.                    case COMMA:
2898.                    {
2899.                        break;
2900.                    }
2901.                    default:
2902.                    {
2903.                        throw new NoViableAltException(LT(1), getFilename());
2904.                    }
2905.                    }
2906.                    }
2907.                }
2908.                else {
2909.                    break _loop180;
2910.                }
2911.                
2912.            } while (true);
2913.            }
2914.            }
2915.            if ( inputState.guessing==0 ) {
2916.                m.endMemberDeclaratorList();
2917.            }
2918.        }
2919.        
2920.        public final void ctor_declarator() throws RecognitionException, TokenStreamException {
2921.            
2922.                String q="";
2923.            
2924.            q=qualified_ctor_id();
2925.            if ( inputState.guessing==0 ) {
2926.                m.qualifiedCtorId(q);
2927.            }
2928.            match(LPAREN);
2929.            {
2930.            switch ( LA(1)) {
2931.            case LITERAL_typedef:
2932.            case LITERAL_enum:
2933.            case ID:
2934.            case LITERAL_inline:
2935.            case LITERAL_extern:
2936.            case LITERAL__inline:
2937.            case LITERAL___inline:
2938.            case LITERAL_virtual:
2939.            case LITERAL_explicit:
2940.            case LITERAL_friend:
2941.            case LITERAL__stdcall:
2942.            case LITERAL___stdcall:
2943.            case LITERAL__declspec:
2944.            case LITERAL___declspec:
2945.            case LPAREN:
2946.            case LITERAL_typename:
2947.            case LITERAL_auto:
2948.            case LITERAL_register:
2949.            case LITERAL_static:
2950.            case LITERAL_mutable:
2951.            case LITERAL_const:
2952.            case LITERAL_const_cast:
2953.            case LITERAL_volatile:
2954.            case LITERAL_char:
2955.            case LITERAL_wchar_t:
2956.            case LITERAL_bool:
2957.            case LITERAL_short:
2958.            case LITERAL_int:
2959.            case 44:
2960.            case 45:
2961.            case 46:
2962.            case LITERAL_long:
2963.            case LITERAL_signed:
2964.            case LITERAL_unsigned:
2965.            case LITERAL_float:
2966.            case LITERAL_double:
2967.            case LITERAL_void:
2968.            case LITERAL_class:
2969.            case LITERAL_struct:
2970.            case LITERAL_union:
2971.            case OPERATOR:
2972.            case LITERAL_this:
2973.            case LITERAL_true:
2974.            case LITERAL_false:
2975.            case STAR:
2976.            case AMPERSAND:
2977.            case TILDE:
2978.            case ELLIPSIS:
2979.            case SCOPE:
2980.            case LITERAL__cdecl:
2981.            case LITERAL___cdecl:
2982.            case LITERAL__near:
2983.            case LITERAL___near:
2984.            case LITERAL__far:
2985.            case LITERAL___far:
2986.            case LITERAL___interrupt:
2987.            case LITERAL_pascal:
2988.            case LITERAL__pascal:
2989.            case LITERAL___pascal:
2990.            {
2991.                parameter_list();
2992.                break;
2993.            }
2994.            case RPAREN:
2995.            {
2996.                break;
2997.            }
2998.            default:
2999.            {
3000.                throw new NoViableAltException(LT(1), getFilename());
3001.            }
3002.            }
3003.            }
3004.            match(RPAREN);
3005.            {
3006.            switch ( LA(1)) {
3007.            case LITERAL_throw:
3008.            {
3009.                exception_specification();
3010.                break;
3011.            }
3012.            case LCURLY:
3013.            case SEMICOLON:
3014.            case COLON:
3015.            {
3016.                break;
3017.            }
3018.            default:
3019.            {
3020.                throw new NoViableAltException(LT(1), getFilename());
3021.            }
3022.            }
3023.            }
3024.        }
3025.        
3026.        public final void compound_statement() throws RecognitionException, TokenStreamException {
3027.            
3028.            
3029.            if ( inputState.guessing==0 ) {
3030.                m.beginCompoundStatement();
3031.            }
3032.            match(LCURLY);
3033.            {
3034.            switch ( LA(1)) {
3035.            case LITERAL_typedef:
3036.            case LITERAL_enum:
3037.            case ID:
3038.            case LCURLY:
3039.            case SEMICOLON:
3040.            case LITERAL_inline:
3041.            case LITERAL_extern:
3042.            case StringLiteral:
3043.            case LITERAL__inline:
3044.            case LITERAL___inline:
3045.            case LITERAL_virtual:
3046.            case LITERAL_explicit:
3047.            case LITERAL_friend:
3048.            case LITERAL__stdcall:
3049.            case LITERAL___stdcall:
3050.            case LITERAL__declspec:
3051.            case LITERAL___declspec:
3052.            case LPAREN:
3053.            case LITERAL_typename:
3054.            case LITERAL_auto:
3055.            case LITERAL_register:
3056.            case LITERAL_static:
3057.            case LITERAL_mutable:
3058.            case LITERAL_const:
3059.            case LITERAL_const_cast:
3060.            case LITERAL_volatile:
3061.            case LITERAL_char:
3062.            case LITERAL_wchar_t:
3063.            case LITERAL_bool:
3064.            case LITERAL_short:
3065.            case LITERAL_int:
3066.            case 44:
3067.            case 45:
3068.            case 46:
3069.            case LITERAL_long:
3070.            case LITERAL_signed:
3071.            case LITERAL_unsigned:
3072.            case LITERAL_float:
3073.            case LITERAL_double:
3074.            case LITERAL_void:
3075.            case LITERAL_class:
3076.            case LITERAL_struct:
3077.            case LITERAL_union:
3078.            case OPERATOR:
3079.            case LITERAL_this:
3080.            case LITERAL_true:
3081.            case LITERAL_false:
3082.            case OCTALINT:
3083.            case STAR:
3084.            case AMPERSAND:
3085.            case TILDE:
3086.            case LITERAL_throw:
3087.            case LITERAL_case:
3088.            case LITERAL_default:
3089.            case LITERAL_if:
3090.            case LITERAL_switch:
3091.            case LITERAL_while:
3092.            case LITERAL_do:
3093.            case LITERAL_for:
3094.            case LITERAL_goto:
3095.            case LITERAL_continue:
3096.            case LITERAL_break:
3097.            case LITERAL_return:
3098.            case LITERAL_try:
3099.            case LITERAL_using:
3100.            case LITERAL__asm:
3101.            case LITERAL___asm:
3102.            case PLUS:
3103.            case MINUS:
3104.            case PLUSPLUS:
3105.            case MINUSMINUS:
3106.            case LITERAL_sizeof:
3107.            case SCOPE:
3108.            case LITERAL_dynamic_cast:
3109.            case LITERAL_static_cast:
3110.            case LITERAL_reinterpret_cast:
3111.            case NOT:
3112.            case LITERAL_new:
3113.            case LITERAL_delete:
3114.            case DECIMALINT:
3115.            case HEXADECIMALINT:
3116.            case CharLiteral:
3117.            case FLOATONE:
3118.            case FLOATTWO:
3119.            {
3120.                statement_list();
3121.                break;
3122.            }
3123.            case RCURLY:
3124.            {
3125.                break;
3126.            }
3127.            default:
3128.            {
3129.                throw new NoViableAltException(LT(1), getFilename());
3130.            }
3131.            }
3132.            }
3133.            match(RCURLY);
3134.            if ( inputState.guessing==0 ) {
3135.                m.endCompoundStatement();
3136.            }
3137.        }
3138.        
3139.        public final void access_specifier() throws RecognitionException, TokenStreamException {
3140.            
3141.            
3142.            switch ( LA(1)) {
3143.            case LITERAL_public:
3144.            {
3145.                match(LITERAL_public);
3146.                if ( inputState.guessing==0 ) {
3147.                    m.accessSpecifier("public");
3148.                }
3149.                break;
3150.            }
3151.            case LITERAL_protected:
3152.            {
3153.                match(LITERAL_protected);
3154.                if ( inputState.guessing==0 ) {
3155.                    m.accessSpecifier("protected");
3156.                }
3157.                break;
3158.            }
3159.            case LITERAL_private:
3160.            {
3161.                match(LITERAL_private);
3162.                if ( inputState.guessing==0 ) {
3163.                    m.accessSpecifier("private");
3164.                }
3165.                break;
3166.            }
3167.            default:
3168.            {
3169.                throw new NoViableAltException(LT(1), getFilename());
3170.            }
3171.            }
3172.        }
3173.        
3174.        public final void linkage_specification() throws RecognitionException, TokenStreamException {
3175.            
3176.            
3177.            match(LITERAL_extern);
3178.            match(StringLiteral);
3179.            {
3180.            switch ( LA(1)) {
3181.            case LCURLY:
3182.            {
3183.                match(LCURLY);
3184.                {
3185.                _loop112:
3186.                do {
3187.                    if ((_tokenSet_0.member(LA(1)))) {
3188.                        external_declaration();
3189.                    }
3190.                    else {
3191.                        break _loop112;
3192.                    }
3193.                    
3194.                } while (true);
3195.                }
3196.                match(RCURLY);
3197.                break;
3198.            }
3199.            case LITERAL_typedef:
3200.            case LITERAL_enum:
3201.            case ID:
3202.            case LITERAL_inline:
3203.            case LITERAL_extern:
3204.            case LITERAL__inline:
3205.            case LITERAL___inline:
3206.            case LITERAL_virtual:
3207.            case LITERAL_explicit:
3208.            case LITERAL_friend:
3209.            case LITERAL__stdcall:
3210.            case LITERAL___stdcall:
3211.            case LITERAL__declspec:
3212.            case LITERAL___declspec:
3213.            case LITERAL_typename:
3214.            case LITERAL_auto:
3215.            case LITERAL_register:
3216.            case LITERAL_static:
3217.            case LITERAL_mutable:
3218.            case LITERAL_const:
3219.            case LITERAL_const_cast:
3220.            case LITERAL_volatile:
3221.            case LITERAL_char:
3222.            case LITERAL_wchar_t:
3223.            case LITERAL_bool:
3224.            case LITERAL_short:
3225.            case LITERAL_int:
3226.            case 44:
3227.            case 45:
3228.            case 46:
3229.            case LITERAL_long:
3230.            case LITERAL_signed:
3231.            case LITERAL_unsigned:
3232.            case LITERAL_float:
3233.            case LITERAL_double:
3234.            case LITERAL_void:
3235.            case LITERAL_class:
3236.            case LITERAL_struct:
3237.            case LITERAL_union:
3238.            case LITERAL_using:
3239.            case SCOPE:
3240.            {
3241.                declaration();
3242.                break;
3243.            }
3244.            default:
3245.            {
3246.                throw new NoViableAltException(LT(1), getFilename());
3247.            }
3248.            }
3249.            }
3250.        }
3251.        
3252.        public final void using_declaration() throws RecognitionException, TokenStreamException {
3253.            
3254.            String qid="";
3255.            
3256.            match(LITERAL_using);
3257.            {
3258.            switch ( LA(1)) {
3259.            case LITERAL_namespace:
3260.            {
3261.                match(LITERAL_namespace);
3262.                qid=qualified_id();
3263.                break;
3264.            }
3265.            case ID:
3266.            case OPERATOR:
3267.            case LITERAL_this:
3268.            case LITERAL_true:
3269.            case LITERAL_false:
3270.            case SCOPE:
3271.            {
3272.                qid=qualified_id();
3273.                break;
3274.            }
3275.            default:
3276.            {
3277.                throw new NoViableAltException(LT(1), getFilename());
3278.            }
3279.            }
3280.            }
3281.            match(SEMICOLON);
3282.        }
3283.        
3284.        public final void storage_class_specifier() throws RecognitionException, TokenStreamException {
3285.            
3286.            
3287.            switch ( LA(1)) {
3288.            case LITERAL_auto:
3289.            {
3290.                match(LITERAL_auto);
3291.                if ( inputState.guessing==0 ) {
3292.                    m.storageClassSpecifier("auto");
3293.                }
3294.                break;
3295.            }
3296.            case LITERAL_register:
3297.            {
3298.                match(LITERAL_register);
3299.                if ( inputState.guessing==0 ) {
3300.                    m.storageClassSpecifier("register");
3301.                }
3302.                break;
3303.            }
3304.            case LITERAL_static:
3305.            {
3306.                match(LITERAL_static);
3307.                if ( inputState.guessing==0 ) {
3308.                    m.storageClassSpecifier("static");
3309.                }
3310.                break;
3311.            }
3312.            case LITERAL_extern:
3313.            {
3314.                match(LITERAL_extern);
3315.                if ( inputState.guessing==0 ) {
3316.                    m.storageClassSpecifier("extern");
3317.                }
3318.                break;
3319.            }
3320.            case LITERAL_mutable:
3321.            {
3322.                match(LITERAL_mutable);
3323.                if ( inputState.guessing==0 ) {
3324.                    m.storageClassSpecifier("mutable");
3325.                }
3326.                break;
3327.            }
3328.            default:
3329.            {
3330.                throw new NoViableAltException(LT(1), getFilename());
3331.            }
3332.            }
3333.        }
3334.        
3335.        public final void type_qualifier() throws RecognitionException, TokenStreamException {
3336.            
3337.            
3338.            switch ( LA(1)) {
3339.            case LITERAL_const:
3340.            case LITERAL_const_cast:
3341.            {
3342.                {
3343.                switch ( LA(1)) {
3344.                case LITERAL_const:
3345.                {
3346.                    match(LITERAL_const);
3347.                    break;
3348.                }
3349.                case LITERAL_const_cast:
3350.                {
3351.                    match(LITERAL_const_cast);
3352.                    break;
3353.                }
3354.                default:
3355.                {
3356.                    throw new NoViableAltException(LT(1), getFilename());
3357.                }
3358.                }
3359.                }
3360.                if ( inputState.guessing==0 ) {
3361.                    m.typeQualifier("const");
3362.                }
3363.                break;
3364.            }
3365.            case LITERAL_volatile:
3366.            {
3367.                match(LITERAL_volatile);
3368.                if ( inputState.guessing==0 ) {
3369.                    m.typeQualifier("volatile");
3370.                }
3371.                break;
3372.            }
3373.            default:
3374.            {
3375.                throw new NoViableAltException(LT(1), getFilename());
3376.            }
3377.            }
3378.        }
3379.        
3380.        public final void type_specifier() throws RecognitionException, TokenStreamException {
3381.            
3382.            
3383.            switch ( LA(1)) {
3384.            case ID:
3385.            case LITERAL__declspec:
3386.            case LITERAL___declspec:
3387.            case LITERAL_char:
3388.            case LITERAL_wchar_t:
3389.            case LITERAL_bool:
3390.            case LITERAL_short:
3391.            case LITERAL_int:
3392.            case 44:
3393.            case 45:
3394.            case 46:
3395.            case LITERAL_long:
3396.            case LITERAL_signed:
3397.            case LITERAL_unsigned:
3398.            case LITERAL_float:
3399.            case LITERAL_double:
3400.            case LITERAL_void:
3401.            case SCOPE:
3402.            {
3403.                simple_type_specifier();
3404.                break;
3405.            }
3406.            case LITERAL_class:
3407.            case LITERAL_struct:
3408.            case LITERAL_union:
3409.            {
3410.                class_specifier();
3411.                break;
3412.            }
3413.            case LITERAL_enum:
3414.            {
3415.                enum_specifier();
3416.                break;
3417.            }
3418.            default:
3419.            {
3420.                throw new NoViableAltException(LT(1), getFilename());
3421.            }
3422.            }
3423.        }
3424.        
3425.        public final void direct_declarator() throws RecognitionException, TokenStreamException {
3426.            
3427.            Token  dtor = null;
3428.            String id="";
3429.            
3430.            switch ( LA(1)) {
3431.            case TILDE:
3432.            {
3433.                match(TILDE);
3434.                dtor = LT(1);
3435.                match(ID);
3436.                if ( inputState.guessing==0 ) {
3437.                    declaratorID(dtor.getText(),CPPvariables.QI_DTOR);
3438.                }
3439.                match(LPAREN);
3440.                {
3441.                switch ( LA(1)) {
3442.                case LITERAL_typedef:
3443.                case LITERAL_enum:
3444.                case ID:
3445.                case LITERAL_inline:
3446.                case LITERAL_extern:
3447.                case LITERAL__inline:
3448.                case LITERAL___inline:
3449.                case LITERAL_virtual:
3450.                case LITERAL_explicit:
3451.                case LITERAL_friend:
3452.                case LITERAL__stdcall:
3453.                case LITERAL___stdcall:
3454.                case LITERAL__declspec:
3455.                case LITERAL___declspec:
3456.                case LPAREN:
3457.                case LITERAL_typename:
3458.                case LITERAL_auto:
3459.                case LITERAL_register:
3460.                case LITERAL_static:
3461.                case LITERAL_mutable:
3462.                case LITERAL_const:
3463.                case LITERAL_const_cast:
3464.                case LITERAL_volatile:
3465.                case LITERAL_char:
3466.                case LITERAL_wchar_t:
3467.                case LITERAL_bool:
3468.                case LITERAL_short:
3469.                case LITERAL_int:
3470.                case 44:
3471.                case 45:
3472.                case 46:
3473.                case LITERAL_long:
3474.                case LITERAL_signed:
3475.                case LITERAL_unsigned:
3476.                case LITERAL_float:
3477.                case LITERAL_double:
3478.                case LITERAL_void:
3479.                case LITERAL_class:
3480.                case LITERAL_struct:
3481.                case LITERAL_union:
3482.                case OPERATOR:
3483.                case LITERAL_this:
3484.                case LITERAL_true:
3485.                case LITERAL_false:
3486.                case STAR:
3487.                case AMPERSAND:
3488.                case TILDE:
3489.                case ELLIPSIS:
3490.                case SCOPE:
3491.                case LITERAL__cdecl:
3492.                case LITERAL___cdecl:
3493.                case LITERAL__near:
3494.                case LITERAL___near:
3495.                case LITERAL__far:
3496.                case LITERAL___far:
3497.                case LITERAL___interrupt:
3498.                case LITERAL_pascal:
3499.                case LITERAL__pascal:
3500.                case LITERAL___pascal:
3501.                {
3502.                    parameter_list();
3503.                    break;
3504.                }
3505.                case RPAREN:
3506.                {
3507.                    break;
3508.                }
3509.                default:
3510.                {
3511.                    throw new NoViableAltException(LT(1), getFilename());
3512.                }
3513.                }
3514.                }
3515.                match(RPAREN);
3516.                break;
3517.            }
3518.            case LPAREN:
3519.            {
3520.                match(LPAREN);
3521.                declarator();
3522.                match(RPAREN);
3523.                declarator_suffixes();
3524.                break;
3525.            }
3526.            default:
3527.                boolean synPredMatched203 = false;
3528.                if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3529.                    int _m203 = mark();
3530.                    synPredMatched203 = true;
3531.                    inputState.guessing++;
3532.                    try {
3533.                        {
3534.                        qualified_id();
3535.                        match(LPAREN);
3536.                        {
3537.                        switch ( LA(1)) {
3538.                        case RPAREN:
3539.                        {
3540.                            match(RPAREN);
3541.                            break;
3542.                        }
3543.                        case LITERAL_typedef:
3544.                        case LITERAL_enum:
3545.                        case ID:
3546.                        case LITERAL_inline:
3547.                        case LITERAL_extern:
3548.                        case LITERAL__inline:
3549.                        case LITERAL___inline:
3550.                        case LITERAL_virtual:
3551.                        case LITERAL_explicit:
3552.                        case LITERAL_friend:
3553.                        case LITERAL__stdcall:
3554.                        case LITERAL___stdcall:
3555.                        case LITERAL__declspec:
3556.                        case LITERAL___declspec:
3557.                        case LITERAL_typename:
3558.                        case LITERAL_auto:
3559.                        case LITERAL_register:
3560.                        case LITERAL_static:
3561.                        case LITERAL_mutable:
3562.                        case LITERAL_const:
3563.                        case LITERAL_const_cast:
3564.                        case LITERAL_volatile:
3565.                        case LITERAL_char:
3566.                        case LITERAL_wchar_t:
3567.                        case LITERAL_bool:
3568.                        case LITERAL_short:
3569.                        case LITERAL_int:
3570.                        case 44:
3571.                        case 45:
3572.                        case 46:
3573.                        case LITERAL_long:
3574.                        case LITERAL_signed:
3575.                        case LITERAL_unsigned:
3576.                        case LITERAL_float:
3577.                        case LITERAL_double:
3578.                        case LITERAL_void:
3579.                        case LITERAL_class:
3580.                        case LITERAL_struct:
3581.                        case LITERAL_union:
3582.                        case SCOPE:
3583.                        {
3584.                            declaration_specifiers();
3585.                            break;
3586.                        }
3587.                        default:
3588.                        {
3589.                            throw new NoViableAltException(LT(1), getFilename());
3590.                        }
3591.                        }
3592.                        }
3593.                        }
3594.                    }
3595.                    catch (RecognitionException pe) {
3596.                        synPredMatched203 = false;
3597.                    }
3598.                    rewind(_m203);
3599.    inputState.guessing--;
3600.                }
3601.                if ( synPredMatched203 ) {
3602.                    id=qualified_id();
3603.                    if ( inputState.guessing==0 ) {
3604.                        declaratorID(id,CPPvariables.QI_FUN); m.directDeclarator(id, _td);
3605.                    }
3606.                    match(LPAREN);
3607.                    {
3608.                    switch ( LA(1)) {
3609.                    case LITERAL_typedef:
3610.                    case LITERAL_enum:
3611.                    case ID:
3612.                    case LITERAL_inline:
3613.                    case LITERAL_extern:
3614.                    case LITERAL__inline:
3615.                    case LITERAL___inline:
3616.                    case LITERAL_virtual:
3617.                    case LITERAL_explicit:
3618.                    case LITERAL_friend:
3619.                    case LITERAL__stdcall:
3620.                    case LITERAL___stdcall:
3621.                    case LITERAL__declspec:
3622.                    case LITERAL___declspec:
3623.                    case LPAREN:
3624.                    case LITERAL_typename:
3625.                    case LITERAL_auto:
3626.                    case LITERAL_register:
3627.                    case LITERAL_static:
3628.                    case LITERAL_mutable:
3629.                    case LITERAL_const:
3630.                    case LITERAL_const_cast:
3631.                    case LITERAL_volatile:
3632.                    case LITERAL_char:
3633.                    case LITERAL_wchar_t:
3634.                    case LITERAL_bool:
3635.                    case LITERAL_short:
3636.                    case LITERAL_int:
3637.                    case 44:
3638.                    case 45:
3639.                    case 46:
3640.                    case LITERAL_long:
3641.                    case LITERAL_signed:
3642.                    case LITERAL_unsigned:
3643.                    case LITERAL_float:
3644.                    case LITERAL_double:
3645.                    case LITERAL_void:
3646.                    case LITERAL_class:
3647.                    case LITERAL_struct:
3648.                    case LITERAL_union:
3649.                    case OPERATOR:
3650.                    case LITERAL_this:
3651.                    case LITERAL_true:
3652.                    case LITERAL_false:
3653.                    case STAR:
3654.                    case AMPERSAND:
3655.                    case TILDE:
3656.                    case ELLIPSIS:
3657.                    case SCOPE:
3658.                    case LITERAL__cdecl:
3659.                    case LITERAL___cdecl:
3660.                    case LITERAL__near:
3661.                    case LITERAL___near:
3662.                    case LITERAL__far:
3663.                    case LITERAL___far:
3664.                    case LITERAL___interrupt:
3665.                    case LITERAL_pascal:
3666.                    case LITERAL__pascal:
3667.                    case LITERAL___pascal:
3668.                    {
3669.                        parameter_list();
3670.                        break;
3671.                    }
3672.                    case RPAREN:
3673.                    {
3674.                        break;
3675.                    }
3676.                    default:
3677.                    {
3678.                        throw new NoViableAltException(LT(1), getFilename());
3679.                    }
3680.                    }
3681.                    }
3682.                    match(RPAREN);
3683.                    {
3684.                    _loop206:
3685.                    do {
3686.                        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
3687.                            type_qualifier();
3688.                        }
3689.                        else {
3690.                            break _loop206;
3691.                        }
3692.                        
3693.                    } while (true);
3694.                    }
3695.                    {
3696.                    switch ( LA(1)) {
3697.                    case LITERAL_throw:
3698.                    {
3699.                        exception_specification();
3700.                        break;
3701.                    }
3702.                    case LESSTHAN:
3703.                    case GREATERTHAN:
3704.                    case ID:
3705.                    case SEMICOLON:
3706.                    case RCURLY:
3707.                    case ASSIGNEQUAL:
3708.                    case COLON:
3709.                    case COMMA:
3710.                    case LITERAL__stdcall:
3711.                    case LITERAL___stdcall:
3712.                    case LPAREN:
3713.                    case RPAREN:
3714.                    case OPERATOR:
3715.                    case LITERAL_this:
3716.                    case LITERAL_true:
3717.                    case LITERAL_false:
3718.                    case STAR:
3719.                    case AMPERSAND:
3720.                    case LSQUARE:
3721.                    case RSQUARE:
3722.                    case TILDE:
3723.                    case ELLIPSIS:
3724.                    case TIMESEQUAL:
3725.                    case DIVIDEEQUAL:
3726.                    case MINUSEQUAL:
3727.                    case PLUSEQUAL:
3728.                    case MODEQUAL:
3729.                    case SHIFTLEFTEQUAL:
3730.                    case SHIFTRIGHTEQUAL:
3731.                    case BITWISEANDEQUAL:
3732.                    case BITWISEXOREQUAL:
3733.                    case BITWISEOREQUAL:
3734.                    case QUESTIONMARK:
3735.                    case OR:
3736.                    case AND:
3737.                    case BITWISEOR:
3738.                    case BITWISEXOR:
3739.                    case NOTEQUAL:
3740.                    case EQUAL:
3741.                    case LESSTHANOREQUALTO:
3742.                    case GREATERTHANOREQUALTO:
3743.                    case SHIFTLEFT:
3744.                    case SHIFTRIGHT:
3745.                    case PLUS:
3746.                    case MINUS:
3747.                    case DIVIDE:
3748.                    case MOD:
3749.                    case DOTMBR:
3750.                    case POINTERTOMBR:
3751.                    case SCOPE:
3752.                    case LITERAL__cdecl:
3753.                    case LITERAL___cdecl:
3754.                    case LITERAL__near:
3755.                    case LITERAL___near:
3756.                    case LITERAL__far:
3757.                    case LITERAL___far:
3758.                    case LITERAL___interrupt:
3759.                    case LITERAL_pascal:
3760.                    case LITERAL__pascal:
3761.                    case LITERAL___pascal:
3762.                    {
3763.                        break;
3764.                    }
3765.                    default:
3766.                    {
3767.                        throw new NoViableAltException(LT(1), getFilename());
3768.                    }
3769.                    }
3770.                    }
3771.                }
3772.                else {
3773.                    boolean synPredMatched209 = false;
3774.                    if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3775.                        int _m209 = mark();
3776.                        synPredMatched209 = true;
3777.                        inputState.guessing++;
3778.                        try {
3779.                            {
3780.                            qualified_id();
3781.                            match(LPAREN);
3782.                            qualified_id();
3783.                            }
3784.                        }
3785.                        catch (RecognitionException pe) {
3786.                            synPredMatched209 = false;
3787.                        }
3788.                        rewind(_m209);
3789.    inputState.guessing--;
3790.                    }
3791.                    if ( synPredMatched209 ) {
3792.                        id=qualified_id();
3793.                        if ( inputState.guessing==0 ) {
3794.                            declaratorID(id,CPPvariables.QI_VAR);
3795.                        }
3796.                        match(LPAREN);
3797.                        expression_list();
3798.                        match(RPAREN);
3799.                    }
3800.                    else {
3801.                        boolean synPredMatched211 = false;
3802.                        if (((_tokenSet_29.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
3803.                            int _m211 = mark();
3804.                            synPredMatched211 = true;
3805.                            inputState.guessing++;
3806.                            try {
3807.                                {
3808.                                qualified_id();
3809.                                match(LSQUARE);
3810.                                }
3811.                            }
3812.                            catch (RecognitionException pe) {
3813.                                synPredMatched211 = false;
3814.                            }
3815.                            rewind(_m211);
3816.    inputState.guessing--;
3817.                        }
3818.                        if ( synPredMatched211 ) {
3819.                            id=qualified_id();
3820.                            if ( inputState.guessing==0 ) {
3821.                                
3822.                                             if (_td==true)
3823.                                                declaratorID(id,CPPvariables.QI_TYPE);
3824.                                             else
3825.                                                declaratorID(id,CPPvariables.QI_VAR); 
3826.                                        
3827.                            }
3828.                            {
3829.                            int _cnt214=0;
3830.                            _loop214:
3831.                            do {
3832.                                if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
3833.                                    match(LSQUARE);
3834.                                    {
3835.                                    switch ( LA(1)) {
3836.                                    case ID:
3837.                                    case StringLiteral:
3838.                                    case LITERAL__declspec:
3839.                                    case LITERAL___declspec:
3840.                                    case LPAREN:
3841.                                    case LITERAL_const_cast:
3842.                                    case LITERAL_char:
3843.                                    case LITERAL_wchar_t:
3844.                                    case LITERAL_bool:
3845.                                    case LITERAL_short:
3846.                                    case LITERAL_int:
3847.                                    case 44:
3848.                                    case 45:
3849.                                    case 46:
3850.                                    case LITERAL_long:
3851.                                    case LITERAL_signed:
3852.                                    case LITERAL_unsigned:
3853.                                    case LITERAL_float:
3854.                                    case LITERAL_double:
3855.                                    case LITERAL_void:
3856.                                    case OPERATOR:
3857.                                    case LITERAL_this:
3858.                                    case LITERAL_true:
3859.                                    case LITERAL_false:
3860.                                    case OCTALINT:
3861.                                    case STAR:
3862.                                    case AMPERSAND:
3863.                                    case TILDE:
3864.                                    case PLUS:
3865.                                    case MINUS:
3866.                                    case PLUSPLUS:
3867.                                    case MINUSMINUS:
3868.                                    case LITERAL_sizeof:
3869.                                    case SCOPE:
3870.                                    case LITERAL_dynamic_cast:
3871.                                    case LITERAL_static_cast:
3872.                                    case LITERAL_reinterpret_cast:
3873.                                    case NOT:
3874.                                    case LITERAL_new:
3875.                                    case LITERAL_delete:
3876.                                    case DECIMALINT:
3877.                                    case HEXADECIMALINT:
3878.                                    case CharLiteral:
3879.                                    case FLOATONE:
3880.                                    case FLOATTWO:
3881.                                    {
3882.                                        constant_expression();
3883.                                        break;
3884.                                    }
3885.                                    case RSQUARE:
3886.                                    {
3887.                                        break;
3888.                                    }
3889.                                    default:
3890.                                    {
3891.                                        throw new NoViableAltException(LT(1), getFilename());
3892.                                    }
3893.                                    }
3894.                                    }
3895.                                    match(RSQUARE);
3896.                                }
3897.                                else {
3898.                                    if ( _cnt214>=1 ) { break _loop214; } else {throw new NoViableAltException(LT(1), getFilenam...
3899.                                }
3900.                                
3901.                                _cnt214++;
3902.                            } while (true);
3903.                            }
3904.                        }
3905.                        else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3906.                            id=qualified_id();
3907.                            if ( inputState.guessing==0 ) {
3908.                                
3909.                                            if (_td==true)
3910.                                                declaratorID(id,CPPvariables.QI_TYPE);
3911.                                             else 
3912.                                                declaratorID(id,CPPvariables.QI_VAR);
3913.                                            m.directDeclarator(id, _td);
3914.                                        
3915.                            }
3916.                        }
3917.                    else {
3918.                        throw new NoViableAltException(LT(1), getFilename());
3919.                    }
3920.                    }}}
3921.                }
3922.                
3923.        public final void simple_type_specifier() throws RecognitionException, TokenStreamException {
3924.            
3925.                String s=""; 
3926.                    java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); 
3927.                    auxBitSet.or(CPPvariables.QI_CTOR);
3928.                    List sts = new ArrayList();
3929.                
3930.            
3931.            {
3932.            if (((LA(1)==ID||LA(1)==SCOPE))&&(qualifiedItemIsOneOf(auxBitSet,0))) {
3933.                s=qualified_type();
3934.                if ( inputState.guessing==0 ) {
3935.                    sts.add(s); m.simpleTypeSpecifier(sts);
3936.                }
3937.            }
3938.            else if ((_tokenSet_34.member(LA(1)))) {
3939.                {
3940.                int _cnt129=0;
3941.                _loop129:
3942.                do {
3943.                    switch ( LA(1)) {
3944.                    case LITERAL_char:
3945.                    {
3946.                        match(LITERAL_char);
3947.                        if ( inputState.guessing==0 ) {
3948.                            sts.add("char");
3949.                        }
3950.                        break;
3951.                    }
3952.                    case LITERAL_wchar_t:
3953.                    {
3954.                        match(LITERAL_wchar_t);
3955.                        if ( inputState.guessing==0 ) {
3956.                            sts.add("wchar_t");
3957.                        }
3958.                        break;
3959.                    }
3960.                    case LITERAL_bool:
3961.                    {
3962.                        match(LITERAL_bool);
3963.                        if ( inputState.guessing==0 ) {
3964.                            sts.add("bool");
3965.                        }
3966.                        break;
3967.                    }
3968.                    case LITERAL_short:
3969.                    {
3970.                        match(LITERAL_short);
3971.                        if ( inputState.guessing==0 ) {
3972.                            sts.add("short");
3973.                        }
3974.                        break;
3975.                    }
3976.                    case LITERAL_int:
3977.                    {
3978.                        match(LITERAL_int);
3979.                        if ( inputState.guessing==0 ) {
3980.                            sts.add("int");
3981.                        }
3982.                        break;
3983.                    }
3984.                    case 44:
3985.                    case 45:
3986.                    {
3987.                        {
3988.                        switch ( LA(1)) {
3989.                        case 44:
3990.                        {
3991.                            match(44);
3992.                            break;
3993.                        }
3994.                        case 45:
3995.                        {
3996.                            match(45);
3997.                            break;
3998.                        }
3999.                        default:
4000.                        {
4001.                            throw new NoViableAltException(LT(1), getFilename());
4002.                        }
4003.                        }
4004.                        }
4005.                        if ( inputState.guessing==0 ) {
4006.                            sts.add("__int64");
4007.                        }
4008.                        break;
4009.                    }
4010.                    case 46:
4011.                    {
4012.                        match(46);
4013.                        if ( inputState.guessing==0 ) {
4014.                            sts.add("__w64");
4015.                        }
4016.                        break;
4017.                    }
4018.                    case LITERAL_long:
4019.                    {
4020.                        match(LITERAL_long);
4021.                        if ( inputState.guessing==0 ) {
4022.                            sts.add("long");
4023.                        }
4024.                        break;
4025.                    }
4026.                    case LITERAL_signed:
4027.                    {
4028.                        match(LITERAL_signed);
4029.                        if ( inputState.guessing==0 ) {
4030.                            sts.add("signed");
4031.                        }
4032.                        break;
4033.                    }
4034.                    case LITERAL_unsigned:
4035.                    {
4036.                        match(LITERAL_unsigned);
4037.                        if ( inputState.guessing==0 ) {
4038.                            sts.add("unsigned");
4039.                        }
4040.                        break;
4041.                    }
4042.                    case LITERAL_float:
4043.                    {
4044.                        match(LITERAL_float);
4045.                        if ( inputState.guessing==0 ) {
4046.                            sts.add("float");
4047.                        }
4048.                        break;
4049.                    }
4050.                    case LITERAL_double:
4051.                    {
4052.                        match(LITERAL_double);
4053.                        if ( inputState.guessing==0 ) {
4054.                            sts.add("double");
4055.                        }
4056.                        break;
4057.                    }
4058.                    case LITERAL_void:
4059.                    {
4060.                        match(LITERAL_void);
4061.                        if ( inputState.guessing==0 ) {
4062.                            sts.add("void");
4063.                        }
4064.                        break;
4065.                    }
4066.                    case LITERAL__declspec:
4067.                    case LITERAL___declspec:
4068.                    {
4069.                        {
4070.                        switch ( LA(1)) {
4071.                        case LITERAL__declspec:
4072.                        {
4073.                            match(LITERAL__declspec);
4074.                            break;
4075.                        }
4076.                        case LITERAL___declspec:
4077.                        {
4078.                            match(LITERAL___declspec);
4079.                            break;
4080.                        }
4081.                        default:
4082.                        {
4083.                            throw new NoViableAltException(LT(1), getFilename());
4084.                        }
4085.                        }
4086.                        }
4087.                        match(LPAREN);
4088.                        match(ID);
4089.                        match(RPAREN);
4090.                        break;
4091.                    }
4092.                    default:
4093.                    {
4094.                        if ( _cnt129>=1 ) { break _loop129; } else {throw new NoViableAltException(LT(1), getFilename()...
4095.                    }
4096.                    }
4097.                    _cnt129++;
4098.                } while (true);
4099.                }
4100.                if ( inputState.guessing==0 ) {
4101.                    m.simpleTypeSpecifier(sts);
4102.                }
4103.            }
4104.            else {
4105.                throw new NoViableAltException(LT(1), getFilename());
4106.            }
4107.            
4108.            }
4109.        }
4110.        
4111.        public final void class_specifier() throws RecognitionException, TokenStreamException {
4112.            
4113.            String saveClass="";String id="";String type="";
4114.            
4115.            {
4116.            switch ( LA(1)) {
4117.            case LITERAL_class:
4118.            {
4119.                match(LITERAL_class);
4120.                if ( inputState.guessing==0 ) {
4121.                    type=CPPvariables.OT_CLASS;
4122.                }
4123.                break;
4124.            }
4125.            case LITERAL_struct:
4126.            {
4127.                match(LITERAL_struct);
4128.                if ( inputState.guessing==0 ) {
4129.                    type=CPPvariables.OT_STRUCT;
4130.                }
4131.                break;
4132.            }
4133.            case LITERAL_union:
4134.            {
4135.                match(LITERAL_union);
4136.                if ( inputState.guessing==0 ) {
4137.                    type=CPPvariables.OT_UNION;
4138.                }
4139.                break;
4140.            }
4141.            default:
4142.            {
4143.                throw new NoViableAltException(LT(1), getFilename());
4144.            }
4145.            }
4146.            }
4147.            {
4148.            switch ( LA(1)) {
4149.            case ID:
4150.            case OPERATOR:
4151.            case LITERAL_this:
4152.            case LITERAL_true:
4153.            case LITERAL_false:
4154.            case SCOPE:
4155.            {
4156.                id=qualified_id();
4157.                {
4158.                if ((LA(1)==LCURLY||LA(1)==COLON) && (_tokenSet_35.member(LA(2)))) {
4159.                    if ( inputState.guessing==0 ) {
4160.                            saveClass = enclosingClass;
4161.                                             enclosingClass = id;
4162.                                        
4163.                    }
4164.                    if ( inputState.guessing==0 ) {
4165.                        m.beginClassDefinition(type, id);
4166.                    }
4167.                    {
4168.                    switch ( LA(1)) {
4169.                    case COLON:
4170.                    {
4171.                        base_clause();
4172.                        break;
4173.                    }
4174.                    case LCURLY:
4175.                    {
4176.                        break;
4177.                    }
4178.                    default:
4179.                    {
4180.                        throw new NoViableAltException(LT(1), getFilename());
4181.                    }
4182.                    }
4183.                    }
4184.                    match(LCURLY);
4185.                    if ( inputState.guessing==0 ) {
4186.                        
4187.                                            if(!symbols.containsKey(id))
4188.                                                symbols.put(id,type);
4189.                                        
4190.                    }
4191.                    {
4192.                    _loop138:
4193.                    do {
4194.                        if ((_tokenSet_36.member(LA(1)))) {
4195.                            member_declaration();
4196.                        }
4197.                        else {
4198.                            break _loop138;
4199.                        }
4200.                        
4201.                    } while (true);
4202.                    }
4203.                    if ( inputState.guessing==0 ) {
4204.                        m.endClassDefinition();
4205.                    }
4206.                    match(RCURLY);
4207.                    if ( inputState.guessing==0 ) {
4208.                            enclosingClass = saveClass;
4209.                    }
4210.                }
4211.                else if ((_tokenSet_37.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4212.                    if ( inputState.guessing==0 ) {
4213.                        
4214.                                            
4215.                                            String auxName=id;
4216.                                            int pos = auxName.indexOf("::");
4217.                                            while(pos>=0)
4218.                                            {
4219.                                                if(!symbols.containsKey(auxName.substring(0,pos)))
4220.                                                    symbols.put(auxName.substring(0,pos),type);
4221.                                                auxName=auxName.substring(pos+2,auxName.length());
4222.                                                pos=auxName.indexOf("::");
4223.                                            }    
4224.                                            if(!symbols.containsKey(auxName))
4225.                                                    symbols.put(auxName,type);
4226.                                        
4227.                    }
4228.                }
4229.                else {
4230.                    throw new NoViableAltException(LT(1), getFilename());
4231.                }
4232.                
4233.                }
4234.                break;
4235.            }
4236.            case LCURLY:
4237.            {
4238.                match(LCURLY);
4239.                if ( inputState.guessing==0 ) {
4240.                        id="anonymous";
4241.                                    saveClass = enclosingClass; enclosingClass = "anonymous";
4242.                                    if(!symbols.containsKey(id))
4243.                                        symbols.put(id,type);
4244.                                
4245.                }
4246.                {
4247.                _loop140:
4248.                do {
4249.                    if ((_tokenSet_36.member(LA(1)))) {
4250.                        member_declaration();
4251.                    }
4252.                    else {
4253.                        break _loop140;
4254.                    }
4255.                    
4256.                } while (true);
4257.                }
4258.                match(RCURLY);
4259.                if ( inputState.guessing==0 ) {
4260.                    enclosingClass = saveClass;
4261.                }
4262.                break;
4263.            }
4264.            default:
4265.            {
4266.                throw new NoViableAltException(LT(1), getFilename());
4267.            }
4268.            }
4269.            }
4270.        }
4271.        
4272.        public final String  qualified_type() throws RecognitionException, TokenStreamException {
4273.            String q="";
4274.            
4275.            Token  id = null;
4276.            String s=""; String  qitem="";
4277.            
4278.            s=scope_override();
4279.            id = LT(1);
4280.            match(ID);
4281.            {
4282.            if ((LA(1)==LESSTHAN) && (_tokenSet_24.member(LA(2)))) {
4283.                match(LESSTHAN);
4284.                template_argument_list();
4285.                match(GREATERTHAN);
4286.            }
4287.            else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4288.            }
4289.            else {
4290.                throw new NoViableAltException(LT(1), getFilename());
4291.            }
4292.            
4293.            }
4294.            if ( inputState.guessing==0 ) {
4295.                
4296.                            qitem=s;
4297.                            qitem=qitem+id.getText();
4298.                            q=qitem;
4299.                        
4300.            }
4301.            return q;
4302.        }
4303.        
4304.        public final void template_argument_list() throws RecognitionException, TokenStreamException {
4305.            
4306.            
4307.            template_argument();
4308.            {
4309.            _loop304:
4310.            do {
4311.                if ((LA(1)==COMMA)) {
4312.                    match(COMMA);
4313.                    template_argument();
4314.                }
4315.                else {
4316.                    break _loop304;
4317.                }
4318.                
4319.            } while (true);
4320.            }
4321.        }
4322.        
4323.        public final void base_clause() throws RecognitionException, TokenStreamException {
4324.            
4325.            
4326.            match(COLON);
4327.            base_specifier();
4328.            {
4329.            _loop170:
4330.            do {
4331.                if ((LA(1)==COMMA)) {
4332.                    match(COMMA);
4333.                    base_specifier();
4334.                }
4335.                else {
4336.                    break _loop170;
4337.                }
4338.                
4339.            } while (true);
4340.            }
4341.        }
4342.        
4343.        public final void enumerator_list() throws RecognitionException, TokenStreamException {
4344.            
4345.            
4346.            enumerator();
4347.            {
4348.            _loop146:
4349.            do {
4350.                if ((LA(1)==COMMA)) {
4351.                    match(COMMA);
4352.                    enumerator();
4353.                }
4354.                else {
4355.                    break _loop146;
4356.                }
4357.                
4358.            } while (true);
4359.            }
4360.        }
4361.        
4362.        public final void enumerator() throws RecognitionException, TokenStreamException {
4363.            
4364.            Token  id = null;
4365.            
4366.            id = LT(1);
4367.            match(ID);
4368.            {
4369.            switch ( LA(1)) {
4370.            case ASSIGNEQUAL:
4371.            {
4372.                match(ASSIGNEQUAL);
4373.                constant_expression();
4374.                break;
4375.            }
4376.            case RCURLY:
4377.            case COMMA:
4378.            {
4379.                break;
4380.            }
4381.            default:
4382.            {
4383.                throw new NoViableAltException(LT(1), getFilename());
4384.            }
4385.            }
4386.            }
4387.        }
4388.        
4389.        public final void constant_expression() throws RecognitionException, TokenStreamException {
4390.            
4391.            
4392.            conditional_expression();
4393.        }
4394.        
4395.        public final void optor() throws RecognitionException, TokenStreamException {
4396.            
4397.            
4398.            switch ( LA(1)) {
4399.            case LITERAL_new:
4400.            {
4401.                match(LITERAL_new);
4402.                {
4403.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4404.                    match(LSQUARE);
4405.                    match(RSQUARE);
4406.                }
4407.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4408.                }
4409.                else {
4410.                    throw new NoViableAltException(LT(1), getFilename());
4411.                }
4412.                
4413.                }
4414.                break;
4415.            }
4416.            case LITERAL_delete:
4417.            {
4418.                match(LITERAL_delete);
4419.                {
4420.                if ((LA(1)==LSQUARE) && (LA(2)==RSQUARE)) {
4421.                    match(LSQUARE);
4422.                    match(RSQUARE);
4423.                }
4424.                else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
4425.                }
4426.                else {
4427.                    throw new NoViableAltException(LT(1), getFilename());
4428.                }
4429.                
4430.                }
4431.                break;
4432.            }
4433.            case LPAREN:
4434.            {
4435.                match(LPAREN);
4436.                match(RPAREN);
4437.                break;
4438.            }
4439.            case LSQUARE:
4440.            {
4441.                match(LSQUARE);
4442.                match(RSQUARE);
4443.                break;
4444.            }
4445.            case LESSTHAN:
4446.            case GREATERTHAN:
4447.            case ASSIGNEQUAL:
4448.            case COMMA:
4449.            case STAR:
4450.            case AMPERSAND:
4451.            case TILDE:
4452.            case TIMESEQUAL:
4453.            case DIVIDEEQUAL:
4454.            case MINUSEQUAL:
4455.            case PLUSEQUAL:
4456.            case MODEQUAL:
4457.            case SHIFTLEFTEQUAL:
4458.            case SHIFTRIGHTEQUAL:
4459.            case BITWISEANDEQUAL:
4460.            case BITWISEXOREQUAL:
4461.            case BITWISEOREQUAL:
4462.            case OR:
4463.            case AND:
4464.            case BITWISEOR:
4465.            case BITWISEXOR:
4466.            case NOTEQUAL:
4467.            case EQUAL:
4468.            case LESSTHANOREQUALTO:
4469.            case GREATERTHANOREQUALTO:
4470.            case SHIFTLEFT:
4471.            case SHIFTRIGHT:
4472.            case PLUS:
4473.            case MINUS:
4474.            case DIVIDE:
4475.            case MOD:
4476.            case POINTERTOMBR:
4477.            case PLUSPLUS:
4478.            case MINUSMINUS:
4479.            case POINTERTO:
4480.            case NOT:
4481.            {
4482.                optor_simple_tokclass();
4483.                break;
4484.            }
4485.            default:
4486.            {
4487.                throw new NoViableAltException(LT(1), getFilename());
4488.            }
4489.            }
4490.        }
4491.        
4492.        public final void typeID() throws RecognitionException, TokenStreamException {
4493.            
4494.            
4495.            if (!(isTypeName(LT(1).getText())))
4496.              throw new SemanticException("isTypeName(LT(1).getText())");
4497.            match(ID);
4498.        }
4499.        
4500.        public final void init_declarator() throws RecognitionException, TokenStreamException {
4501.            
4502.            
4503.            declarator();
4504.            {
4505.            switch ( LA(1)) {
4506.            case ASSIGNEQUAL:
4507.            {
4508.                match(ASSIGNEQUAL);
4509.                initializer();
4510.                break;
4511.            }
4512.            case LPAREN:
4513.            {
4514.                match(LPAREN);
4515.                expression_list();
4516.                match(RPAREN);
4517.                break;
4518.            }
4519.            case SEMICOLON:
4520.            case COMMA:
4521.            {
4522.                break;
4523.            }
4524.            default:
4525.            {
4526.                throw new NoViableAltException(LT(1), getFilename());
4527.            }
4528.            }
4529.            }
4530.        }
4531.        
4532.        public final void declarator() throws RecognitionException, TokenStreamException {
4533.            
4534.            
4535.            boolean synPredMatched199 = false;
4536.            if (((_tokenSet_13.member(LA(1))) && (_tokenSet_39.member(LA(2))))) {
4537.                int _m199 = mark();
4538.                synPredMatched199 = true;
4539.                inputState.guessing++;
4540.                try {
4541.                    {
4542.                    ptr_operator();
4543.                    }
4544.                }
4545.                catch (RecognitionException pe) {
4546.                    synPredMatched199 = false;
4547.                }
4548.                rewind(_m199);
4549.    inputState.guessing--;
4550.            }
4551.            if ( synPredMatched199 ) {
4552.                ptr_operator();
4553.                declarator();
4554.            }
4555.            else if ((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
4556.                direct_declarator();
4557.            }
4558.            else {
4559.                throw new NoViableAltException(LT(1), getFilename());
4560.            }
4561.            
4562.        }
4563.        
4564.        public final void initializer() throws RecognitionException, TokenStreamException {
4565.            
4566.            
4567.            if ( inputState.guessing==0 ) {
4568.                m.beginInitializer();
4569.            }
4570.            {
4571.            switch ( LA(1)) {
4572.            case ID:
4573.            case StringLiteral:
4574.            case LITERAL__declspec:
4575.            case LITERAL___declspec:
4576.            case LPAREN:
4577.            case LITERAL_const_cast:
4578.            case LITERAL_char:
4579.            case LITERAL_wchar_t:
4580.            case LITERAL_bool:
4581.            case LITERAL_short:
4582.            case LITERAL_int:
4583.            case 44:
4584.            case 45:
4585.            case 46:
4586.            case LITERAL_long:
4587.            case LITERAL_signed:
4588.            case LITERAL_unsigned:
4589.            case LITERAL_float:
4590.            case LITERAL_double:
4591.            case LITERAL_void:
4592.            case OPERATOR:
4593.            case LITERAL_this:
4594.            case LITERAL_true:
4595.            case LITERAL_false:
4596.            case OCTALINT:
4597.            case STAR:
4598.            case AMPERSAND:
4599.            case TILDE:
4600.            case PLUS:
4601.            case MINUS:
4602.            case PLUSPLUS:
4603.            case MINUSMINUS:
4604.            case LITERAL_sizeof:
4605.            case SCOPE:
4606.            case LITERAL_dynamic_cast:
4607.            case LITERAL_static_cast:
4608.            case LITERAL_reinterpret_cast:
4609.            case NOT:
4610.            case LITERAL_new:
4611.            case LITERAL_delete:
4612.            case DECIMALINT:
4613.            case HEXADECIMALINT:
4614.            case CharLiteral:
4615.            case FLOATONE:
4616.            case FLOATTWO:
4617.            {
4618.                remainder_expression();
4619.                break;
4620.            }
4621.            case LCURLY:
4622.            {
4623.                match(LCURLY);
4624.                initializer();
4625.                {
4626.                _loop162:
4627.                do {
4628.                    if ((LA(1)==COMMA)) {
4629.                        match(COMMA);
4630.                        initializer();
4631.                    }
4632.                    else {
4633.                        break _loop162;
4634.                    }
4635.                    
4636.                } while (true);
4637.                }
4638.                match(RCURLY);
4639.                break;
4640.            }
4641.            default:
4642.            {
4643.                throw new NoViableAltException(LT(1), getFilename());
4644.            }
4645.            }
4646.            }
4647.            if ( inputState.guessing==0 ) {
4648.                m.endInitializer();
4649.            }
4650.        }
4651.        
4652.        public final void expression_list() throws RecognitionException, TokenStreamException {
4653.            
4654.            
4655.            assignment_expression();
4656.            {
4657.            _loop465:
4658.            do {
4659.                if ((LA(1)==COMMA)) {
4660.                    match(COMMA);
4661.                    assignment_expression();
4662.                }
4663.                else {
4664.                    break _loop465;
4665.                }
4666.                
4667.            } while (true);
4668.            }
4669.        }
4670.        
4671.        public final void remainder_expression() throws RecognitionException, TokenStreamException {
4672.            
4673.            
4674.            {
4675.            boolean synPredMatched355 = false;
4676.            if (((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2))))) {
4677.                int _m355 = mark();
4678.                synPredMatched355 = true;
4679.                inputState.guessing++;
4680.                try {
4681.                    {
4682.                    conditional_expression();
4683.                    {
4684.                    switch ( LA(1)) {
4685.                    case COMMA:
4686.                    {
4687.                        match(COMMA);
4688.                        break;
4689.                    }
4690.                    case SEMICOLON:
4691.                    {
4692.                        match(SEMICOLON);
4693.                        break;
4694.                    }
4695.                    case RPAREN:
4696.                    {
4697.                        match(RPAREN);
4698.                        break;
4699.                    }
4700.                    default:
4701.                    {
4702.                        throw new NoViableAltException(LT(1), getFilename());
4703.                    }
4704.                    }
4705.                    }
4706.                    }
4707.                }
4708.                catch (RecognitionException pe) {
4709.                    synPredMatched355 = false;
4710.                }
4711.                rewind(_m355);
4712.    inputState.guessing--;
4713.            }
4714.            if ( synPredMatched355 ) {
4715.                assignment_expression();
4716.            }
4717.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
4718.                assignment_expression();
4719.            }
4720.            else {
4721.                throw new NoViableAltException(LT(1), getFilename());
4722.            }
4723.            
4724.            }
4725.        }
4726.        
4727.        public final void base_specifier() throws RecognitionException, TokenStreamException {
4728.            
4729.            String qt=""; m.beginBaseSpecifier();
4730.            
4731.            {
4732.            switch ( LA(1)) {
4733.            case LITERAL_virtual:
4734.            {
4735.                match(LITERAL_virtual);
4736.                {
4737.                switch ( LA(1)) {
4738.                case LITERAL_public:
4739.                case LITERAL_protected:
4740.                case LITERAL_private:
4741.                {
4742.                    access_specifier();
4743.                    break;
4744.                }
4745.                case ID:
4746.                case SCOPE:
4747.                {
4748.                    break;
4749.                }
4750.                default:
4751.                {
4752.                    throw new NoViableAltException(LT(1), getFilename());
4753.                }
4754.                }
4755.                }
4756.                qt=qualified_type();
4757.                if ( inputState.guessing==0 ) {
4758.                    m.baseSpecifier(qt, true);
4759.                }
4760.                break;
4761.            }
4762.            case ID:
4763.            case SCOPE:
4764.            {
4765.                qt=qualified_type();
4766.                if ( inputState.guessing==0 ) {
4767.                    m.baseSpecifier(qt, false);
4768.                }
4769.                break;
4770.            }
4771.            default:
4772.                if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==LITERAL_virtual)) {
4773.                    access_specifier();
4774.                    match(LITERAL_virtual);
4775.                    qt=qualified_type();
4776.                    if ( inputState.guessing==0 ) {
4777.                        m.baseSpecifier(qt, true);
4778.                    }
4779.                }
4780.                else if (((LA(1) >= LITERAL_public && LA(1) <= LITERAL_private)) && (LA(2)==ID||LA(2)==SCOPE)) { ...
4781.                    access_specifier();
4782.                    qt=qualified_type();
4783.                    if ( inputState.guessing==0 ) {
4784.                        m.baseSpecifier(qt, false);
4785.                    }
4786.                }
4787.            else {
4788.                throw new NoViableAltException(LT(1), getFilename());
4789.            }
4790.            }
4791.            }
4792.            if ( inputState.guessing==0 ) {
4793.                m.endBaseSpecifier();
4794.            }
4795.        }
4796.        
4797.        public final void member_declarator() throws RecognitionException, TokenStreamException {
4798.            
4799.            m.beginMemberDeclarator();
4800.            
4801.            {
4802.            boolean synPredMatched185 = false;
4803.            if (((LA(1)==ID||LA(1)==COLON) && (_tokenSet_44.member(LA(2))))) {
4804.                int _m185 = mark();
4805.                synPredMatched185 = true;
4806.                inputState.guessing++;
4807.                try {
4808.                    {
4809.                    {
4810.                    switch ( LA(1)) {
4811.                    case ID:
4812.                    {
4813.                        match(ID);
4814.                        break;
4815.                    }
4816.                    case COLON:
4817.                    {
4818.                        break;
4819.                    }
4820.                    default:
4821.                    {
4822.                        throw new NoViableAltException(LT(1), getFilename());
4823.                    }
4824.                    }
4825.                    }
4826.                    match(COLON);
4827.                    constant_expression();
4828.                    }
4829.                }
4830.                catch (RecognitionException pe) {
4831.                    synPredMatched185 = false;
4832.                }
4833.                rewind(_m185);
4834.    inputState.guessing--;
4835.            }
4836.            if ( synPredMatched185 ) {
4837.                {
4838.                switch ( LA(1)) {
4839.                case ID:
4840.                {
4841.                    match(ID);
4842.                    break;
4843.                }
4844.                case COLON:
4845.                {
4846.                    break;
4847.                }
4848.                default:
4849.                {
4850.                    throw new NoViableAltException(LT(1), getFilename());
4851.                }
4852.                }
4853.                }
4854.                match(COLON);
4855.                constant_expression();
4856.            }
4857.            else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4858.                declarator();
4859.            }
4860.            else {
4861.                throw new NoViableAltException(LT(1), getFilename());
4862.            }
4863.            
4864.            }
4865.            if ( inputState.guessing==0 ) {
4866.                m.endMemberDeclarator();
4867.            }
4868.        }
4869.        
4870.        public final void template_parameter_list() throws RecognitionException, TokenStreamException {
4871.            
4872.            
4873.            template_parameter();
4874.            {
4875.            _loop293:
4876.            do {
4877.                if ((LA(1)==COMMA)) {
4878.                    match(COMMA);
4879.                    template_parameter();
4880.                }
4881.                else {
4882.                    break _loop293;
4883.                }
4884.                
4885.            } while (true);
4886.            }
4887.        }
4888.        
4889.        public final void parameter_list() throws RecognitionException, TokenStreamException {
4890.            
4891.            
4892.            parameter_declaration_list();
4893.            {
4894.            switch ( LA(1)) {
4895.            case ELLIPSIS:
4896.            {
4897.                match(ELLIPSIS);
4898.                break;
4899.            }
4900.            case RPAREN:
4901.            {
4902.                break;
4903.            }
4904.            default:
4905.            {
4906.                throw new NoViableAltException(LT(1), getFilename());
4907.            }
4908.            }
4909.            }
4910.        }
4911.        
4912.        public final void exception_specification() throws RecognitionException, TokenStreamException {
4913.            
4914.            String so="";
4915.            
4916.            match(LITERAL_throw);
4917.            match(LPAREN);
4918.            {
4919.            switch ( LA(1)) {
4920.            case ID:
4921.            case RPAREN:
4922.            case SCOPE:
4923.            {
4924.                {
4925.                switch ( LA(1)) {
4926.                case ID:
4927.                case SCOPE:
4928.                {
4929.                    so=scope_override();
4930.                    match(ID);
4931.                    {
4932.                    _loop289:
4933.                    do {
4934.                        if ((LA(1)==COMMA)) {
4935.                            match(COMMA);
4936.                            so=scope_override();
4937.                            match(ID);
4938.                        }
4939.                        else {
4940.                            break _loop289;
4941.                        }
4942.                        
4943.                    } while (true);
4944.                    }
4945.                    break;
4946.                }
4947.                case RPAREN:
4948.                {
4949.                    break;
4950.                }
4951.                default:
4952.                {
4953.                    throw new NoViableAltException(LT(1), getFilename());
4954.                }
4955.                }
4956.                }
4957.                break;
4958.            }
4959.            case ELLIPSIS:
4960.            {
4961.                match(ELLIPSIS);
4962.                break;
4963.            }
4964.            default:
4965.            {
4966.                throw new NoViableAltException(LT(1), getFilename());
4967.            }
4968.            }
4969.            }
4970.            match(RPAREN);
4971.        }
4972.        
4973.        public final void cv_qualifier_seq() throws RecognitionException, TokenStreamException {
4974.            
4975.            
4976.            {
4977.            _loop196:
4978.            do {
4979.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
4980.                    type_qualifier();
4981.                }
4982.                else {
4983.                    break _loop196;
4984.                }
4985.                
4986.            } while (true);
4987.            }
4988.        }
4989.        
4990.        public final void ptr_operator() throws RecognitionException, TokenStreamException {
4991.            
4992.            
4993.            if ( inputState.guessing==0 ) {
4994.                m.beginPtrOperator();
4995.            }
4996.            {
4997.            switch ( LA(1)) {
4998.            case AMPERSAND:
4999.            {
5000.                match(AMPERSAND);
5001.                if ( inputState.guessing==0 ) {
5002.                    m.ptrOperator("&");
5003.                }
5004.                break;
5005.            }
5006.            case LITERAL__cdecl:
5007.            case LITERAL___cdecl:
5008.            {
5009.                {
5010.                switch ( LA(1)) {
5011.                case LITERAL__cdecl:
5012.                {
5013.                    match(LITERAL__cdecl);
5014.                    break;
5015.                }
5016.                case LITERAL___cdecl:
5017.                {
5018.                    match(LITERAL___cdecl);
5019.                    break;
5020.                }
5021.                default:
5022.                {
5023.                    throw new NoViableAltException(LT(1), getFilename());
5024.                }
5025.                }
5026.                }
5027.                break;
5028.            }
5029.            case LITERAL__near:
5030.            case LITERAL___near:
5031.            {
5032.                {
5033.                switch ( LA(1)) {
5034.                case LITERAL__near:
5035.                {
5036.                    match(LITERAL__near);
5037.                    break;
5038.                }
5039.                case LITERAL___near:
5040.                {
5041.                    match(LITERAL___near);
5042.                    break;
5043.                }
5044.                default:
5045.                {
5046.                    throw new NoViableAltException(LT(1), getFilename());
5047.                }
5048.                }
5049.                }
5050.                break;
5051.            }
5052.            case LITERAL__far:
5053.            case LITERAL___far:
5054.            {
5055.                {
5056.                switch ( LA(1)) {
5057.                case LITERAL__far:
5058.                {
5059.                    match(LITERAL__far);
5060.                    break;
5061.                }
5062.                case LITERAL___far:
5063.                {
5064.                    match(LITERAL___far);
5065.                    break;
5066.                }
5067.                default:
5068.                {
5069.                    throw new NoViableAltException(LT(1), getFilename());
5070.                }
5071.                }
5072.                }
5073.                break;
5074.            }
5075.            case LITERAL___interrupt:
5076.            {
5077.                match(LITERAL___interrupt);
5078.                break;
5079.            }
5080.            case LITERAL_pascal:
5081.            case LITERAL__pascal:
5082.            case LITERAL___pascal:
5083.            {
5084.                {
5085.                switch ( LA(1)) {
5086.                case LITERAL_pascal:
5087.                {
5088.                    match(LITERAL_pascal);
5089.                    break;
5090.                }
5091.                case LITERAL__pascal:
5092.                {
5093.                    match(LITERAL__pascal);
5094.                    break;
5095.                }
5096.                case LITERAL___pascal:
5097.                {
5098.                    match(LITERAL___pascal);
5099.                    break;
5100.                }
5101.                default:
5102.                {
5103.                    throw new NoViableAltException(LT(1), getFilename());
5104.                }
5105.                }
5106.                }
5107.                break;
5108.            }
5109.            case LITERAL__stdcall:
5110.            case LITERAL___stdcall:
5111.            {
5112.                {
5113.                switch ( LA(1)) {
5114.                case LITERAL__stdcall:
5115.                {
5116.                    match(LITERAL__stdcall);
5117.                    break;
5118.                }
5119.                case LITERAL___stdcall:
5120.                {
5121.                    match(LITERAL___stdcall);
5122.                    break;
5123.                }
5124.                default:
5125.                {
5126.                    throw new NoViableAltException(LT(1), getFilename());
5127.                }
5128.                }
5129.                }
5130.                break;
5131.            }
5132.            case ID:
5133.            case STAR:
5134.            case SCOPE:
5135.            {
5136.                ptr_to_member();
5137.                break;
5138.            }
5139.            default:
5140.            {
5141.                throw new NoViableAltException(LT(1), getFilename());
5142.            }
5143.            }
5144.            }
5145.            if ( inputState.guessing==0 ) {
5146.                m.endPtrOperator();
5147.            }
5148.        }
5149.        
5150.        public final void declarator_suffixes() throws RecognitionException, TokenStreamException {
5151.            
5152.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5153.            
5154.            {
5155.            if ((LA(1)==LSQUARE)) {
5156.                {
5157.                int _cnt220=0;
5158.                _loop220:
5159.                do {
5160.                    if ((LA(1)==LSQUARE) && (_tokenSet_32.member(LA(2)))) {
5161.                        match(LSQUARE);
5162.                        {
5163.                        switch ( LA(1)) {
5164.                        case ID:
5165.                        case StringLiteral:
5166.                        case LITERAL__declspec:
5167.                        case LITERAL___declspec:
5168.                        case LPAREN:
5169.                        case LITERAL_const_cast:
5170.                        case LITERAL_char:
5171.                        case LITERAL_wchar_t:
5172.                        case LITERAL_bool:
5173.                        case LITERAL_short:
5174.                        case LITERAL_int:
5175.                        case 44:
5176.                        case 45:
5177.                        case 46:
5178.                        case LITERAL_long:
5179.                        case LITERAL_signed:
5180.                        case LITERAL_unsigned:
5181.                        case LITERAL_float:
5182.                        case LITERAL_double:
5183.                        case LITERAL_void:
5184.                        case OPERATOR:
5185.                        case LITERAL_this:
5186.                        case LITERAL_true:
5187.                        case LITERAL_false:
5188.                        case OCTALINT:
5189.                        case STAR:
5190.                        case AMPERSAND:
5191.                        case TILDE:
5192.                        case PLUS:
5193.                        case MINUS:
5194.                        case PLUSPLUS:
5195.                        case MINUSMINUS:
5196.                        case LITERAL_sizeof:
5197.                        case SCOPE:
5198.                        case LITERAL_dynamic_cast:
5199.                        case LITERAL_static_cast:
5200.                        case LITERAL_reinterpret_cast:
5201.                        case NOT:
5202.                        case LITERAL_new:
5203.                        case LITERAL_delete:
5204.                        case DECIMALINT:
5205.                        case HEXADECIMALINT:
5206.                        case CharLiteral:
5207.                        case FLOATONE:
5208.                        case FLOATTWO:
5209.                        {
5210.                            constant_expression();
5211.                            break;
5212.                        }
5213.                        case RSQUARE:
5214.                        {
5215.                            break;
5216.                        }
5217.                        default:
5218.                        {
5219.                            throw new NoViableAltException(LT(1), getFilename());
5220.                        }
5221.                        }
5222.                        }
5223.                        match(RSQUARE);
5224.                    }
5225.                    else {
5226.                        if ( _cnt220>=1 ) { break _loop220; } else {throw new NoViableAltException(LT(1), getFilename()...
5227.                    }
5228.                    
5229.                    _cnt220++;
5230.                } while (true);
5231.                }
5232.            }
5233.            else if (((LA(1)==LPAREN))&&((!((LA(1)==LPAREN)&&(LA(2)==ID))||(qualifiedItemIsOneOf(auxBitSet,1))...
5234.                match(LPAREN);
5235.                {
5236.                switch ( LA(1)) {
5237.                case LITERAL_typedef:
5238.                case LITERAL_enum:
5239.                case ID:
5240.                case LITERAL_inline:
5241.                case LITERAL_extern:
5242.                case LITERAL__inline:
5243.                case LITERAL___inline:
5244.                case LITERAL_virtual:
5245.                case LITERAL_explicit:
5246.                case LITERAL_friend:
5247.                case LITERAL__stdcall:
5248.                case LITERAL___stdcall:
5249.                case LITERAL__declspec:
5250.                case LITERAL___declspec:
5251.                case LPAREN:
5252.                case LITERAL_typename:
5253.                case LITERAL_auto:
5254.                case LITERAL_register:
5255.                case LITERAL_static:
5256.                case LITERAL_mutable:
5257.                case LITERAL_const:
5258.                case LITERAL_const_cast:
5259.                case LITERAL_volatile:
5260.                case LITERAL_char:
5261.                case LITERAL_wchar_t:
5262.                case LITERAL_bool:
5263.                case LITERAL_short:
5264.                case LITERAL_int:
5265.                case 44:
5266.                case 45:
5267.                case 46:
5268.                case LITERAL_long:
5269.                case LITERAL_signed:
5270.                case LITERAL_unsigned:
5271.                case LITERAL_float:
5272.                case LITERAL_double:
5273.                case LITERAL_void:
5274.                case LITERAL_class:
5275.                case LITERAL_struct:
5276.                case LITERAL_union:
5277.                case OPERATOR:
5278.                case LITERAL_this:
5279.                case LITERAL_true:
5280.                case LITERAL_false:
5281.                case STAR:
5282.                case AMPERSAND:
5283.                case TILDE:
5284.                case ELLIPSIS:
5285.                case SCOPE:
5286.                case LITERAL__cdecl:
5287.                case LITERAL___cdecl:
5288.                case LITERAL__near:
5289.                case LITERAL___near:
5290.                case LITERAL__far:
5291.                case LITERAL___far:
5292.                case LITERAL___interrupt:
5293.                case LITERAL_pascal:
5294.                case LITERAL__pascal:
5295.                case LITERAL___pascal:
5296.                {
5297.                    parameter_list();
5298.                    break;
5299.                }
5300.                case RPAREN:
5301.                {
5302.                    break;
5303.                }
5304.                default:
5305.                {
5306.                    throw new NoViableAltException(LT(1), getFilename());
5307.                }
5308.                }
5309.                }
5310.                match(RPAREN);
5311.                {
5312.                _loop223:
5313.                do {
5314.                    if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile))) {
5315.                        type_qualifier();
5316.                    }
5317.                    else {
5318.                        break _loop223;
5319.                    }
5320.                    
5321.                } while (true);
5322.                }
5323.                {
5324.                switch ( LA(1)) {
5325.                case LITERAL_throw:
5326.                {
5327.                    exception_specification();
5328.                    break;
5329.                }
5330.                case LESSTHAN:
5331.                case GREATERTHAN:
5332.                case ID:
5333.                case SEMICOLON:
5334.                case RCURLY:
5335.                case ASSIGNEQUAL:
5336.                case COLON:
5337.                case COMMA:
5338.                case LITERAL__stdcall:
5339.                case LITERAL___stdcall:
5340.                case LPAREN:
5341.                case RPAREN:
5342.                case OPERATOR:
5343.                case LITERAL_this:
5344.                case LITERAL_true:
5345.                case LITERAL_false:
5346.                case STAR:
5347.                case AMPERSAND:
5348.                case LSQUARE:
5349.                case RSQUARE:
5350.                case TILDE:
5351.                case ELLIPSIS:
5352.                case TIMESEQUAL:
5353.                case DIVIDEEQUAL:
5354.                case MINUSEQUAL:
5355.                case PLUSEQUAL:
5356.                case MODEQUAL:
5357.                case SHIFTLEFTEQUAL:
5358.                case SHIFTRIGHTEQUAL:
5359.                case BITWISEANDEQUAL:
5360.                case BITWISEXOREQUAL:
5361.                case BITWISEOREQUAL:
5362.                case QUESTIONMARK:
5363.                case OR:
5364.                case AND:
5365.                case BITWISEOR:
5366.                case BITWISEXOR:
5367.                case NOTEQUAL:
5368.                case EQUAL:
5369.                case LESSTHANOREQUALTO:
5370.                case GREATERTHANOREQUALTO:
5371.                case SHIFTLEFT:
5372.                case SHIFTRIGHT:
5373.                case PLUS:
5374.                case MINUS:
5375.                case DIVIDE:
5376.                case MOD:
5377.                case DOTMBR:
5378.                case POINTERTOMBR:
5379.                case SCOPE:
5380.                case LITERAL__cdecl:
5381.                case LITERAL___cdecl:
5382.                case LITERAL__near:
5383.                case LITERAL___near:
5384.                case LITERAL__far:
5385.                case LITERAL___far:
5386.                case LITERAL___interrupt:
5387.                case LITERAL_pascal:
5388.                case LITERAL__pascal:
5389.                case LITERAL___pascal:
5390.                {
5391.                    break;
5392.                }
5393.                default:
5394.                {
5395.                    throw new NoViableAltException(LT(1), getFilename());
5396.                }
5397.                }
5398.                }
5399.            }
5400.            else {
5401.                throw new NoViableAltException(LT(1), getFilename());
5402.            }
5403.            
5404.            }
5405.        }
5406.        
5407.        public final void function_direct_declarator() throws RecognitionException, TokenStreamException { ...
5408.            
5409.                String q="";
5410.            
5411.            {
5412.            switch ( LA(1)) {
5413.            case LPAREN:
5414.            {
5415.                match(LPAREN);
5416.                q=qualified_id();
5417.                if ( inputState.guessing==0 ) {
5418.                    
5419.                                    declaratorID(q,CPPvariables.QI_FUN);
5420.                                
5421.                }
5422.                match(RPAREN);
5423.                break;
5424.            }
5425.            case ID:
5426.            case OPERATOR:
5427.            case LITERAL_this:
5428.            case LITERAL_true:
5429.            case LITERAL_false:
5430.            case SCOPE:
5431.            {
5432.                q=qualified_id();
5433.                if ( inputState.guessing==0 ) {
5434.                    
5435.                                    declaratorID(q,CPPvariables.QI_FUN);
5436.                                
5437.                }
5438.                break;
5439.            }
5440.            default:
5441.            {
5442.                throw new NoViableAltException(LT(1), getFilename());
5443.            }
5444.            }
5445.            }
5446.            if ( inputState.guessing==0 ) {
5447.                m.functionDirectDeclarator(q);
5448.            }
5449.            match(LPAREN);
5450.            {
5451.            switch ( LA(1)) {
5452.            case LITERAL_typedef:
5453.            case LITERAL_enum:
5454.            case ID:
5455.            case LITERAL_inline:
5456.            case LITERAL_extern:
5457.            case LITERAL__inline:
5458.            case LITERAL___inline:
5459.            case LITERAL_virtual:
5460.            case LITERAL_explicit:
5461.            case LITERAL_friend:
5462.            case LITERAL__stdcall:
5463.            case LITERAL___stdcall:
5464.            case LITERAL__declspec:
5465.            case LITERAL___declspec:
5466.            case LPAREN:
5467.            case LITERAL_typename:
5468.            case LITERAL_auto:
5469.            case LITERAL_register:
5470.            case LITERAL_static:
5471.            case LITERAL_mutable:
5472.            case LITERAL_const:
5473.            case LITERAL_const_cast:
5474.            case LITERAL_volatile:
5475.            case LITERAL_char:
5476.            case LITERAL_wchar_t:
5477.            case LITERAL_bool:
5478.            case LITERAL_short:
5479.            case LITERAL_int:
5480.            case 44:
5481.            case 45:
5482.            case 46:
5483.            case LITERAL_long:
5484.            case LITERAL_signed:
5485.            case LITERAL_unsigned:
5486.            case LITERAL_float:
5487.            case LITERAL_double:
5488.            case LITERAL_void:
5489.            case LITERAL_class:
5490.            case LITERAL_struct:
5491.            case LITERAL_union:
5492.            case OPERATOR:
5493.            case LITERAL_this:
5494.            case LITERAL_true:
5495.            case LITERAL_false:
5496.            case STAR:
5497.            case AMPERSAND:
5498.            case TILDE:
5499.            case ELLIPSIS:
5500.            case SCOPE:
5501.            case LITERAL__cdecl:
5502.            case LITERAL___cdecl:
5503.            case LITERAL__near:
5504.            case LITERAL___near:
5505.            case LITERAL__far:
5506.            case LITERAL___far:
5507.            case LITERAL___interrupt:
5508.            case LITERAL_pascal:
5509.            case LITERAL__pascal:
5510.            case LITERAL___pascal:
5511.            {
5512.                parameter_list();
5513.                break;
5514.            }
5515.            case RPAREN:
5516.            {
5517.                break;
5518.            }
5519.            default:
5520.            {
5521.                throw new NoViableAltException(LT(1), getFilename());
5522.            }
5523.            }
5524.            }
5525.            match(RPAREN);
5526.            {
5527.            _loop232:
5528.            do {
5529.                if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL_volatile)) && (_tokenSet_47.member(LA(2)))) {
5530.                    type_qualifier();
5531.                }
5532.                else {
5533.                    break _loop232;
5534.                }
5535.                
5536.            } while (true);
5537.            }
5538.            {
5539.            switch ( LA(1)) {
5540.            case ASSIGNEQUAL:
5541.            {
5542.                match(ASSIGNEQUAL);
5543.                match(OCTALINT);
5544.                break;
5545.            }
5546.            case LITERAL_typedef:
5547.            case LITERAL_enum:
5548.            case ID:
5549.            case LCURLY:
5550.            case SEMICOLON:
5551.            case LITERAL_inline:
5552.            case LITERAL_extern:
5553.            case LITERAL__inline:
5554.            case LITERAL___inline:
5555.            case LITERAL_virtual:
5556.            case LITERAL_explicit:
5557.            case LITERAL_friend:
5558.            case LITERAL__stdcall:
5559.            case LITERAL___stdcall:
5560.            case LITERAL__declspec:
5561.            case LITERAL___declspec:
5562.            case LITERAL_typename:
5563.            case LITERAL_auto:
5564.            case LITERAL_register:
5565.            case LITERAL_static:
5566.            case LITERAL_mutable:
5567.            case LITERAL_const:
5568.            case LITERAL_const_cast:
5569.            case LITERAL_volatile:
5570.            case LITERAL_char:
5571.            case LITERAL_wchar_t:
5572.            case LITERAL_bool:
5573.            case LITERAL_short:
5574.            case LITERAL_int:
5575.            case 44:
5576.            case 45:
5577.            case 46:
5578.            case LITERAL_long:
5579.            case LITERAL_signed:
5580.            case LITERAL_unsigned:
5581.            case LITERAL_float:
5582.            case LITERAL_double:
5583.            case LITERAL_void:
5584.            case LITERAL_class:
5585.            case LITERAL_struct:
5586.            case LITERAL_union:
5587.            case LITERAL_throw:
5588.            case LITERAL_using:
5589.            case SCOPE:
5590.            {
5591.                break;
5592.            }
5593.            default:
5594.            {
5595.                throw new NoViableAltException(LT(1), getFilename());
5596.            }
5597.            }
5598.            }
5599.            {
5600.            switch ( LA(1)) {
5601.            case LITERAL_throw:
5602.            {
5603.                exception_specification();
5604.                break;
5605.            }
5606.            case LITERAL_typedef:
5607.            case LITERAL_enum:
5608.            case ID:
5609.            case LCURLY:
5610.            case SEMICOLON:
5611.            case LITERAL_inline:
5612.            case LITERAL_extern:
5613.            case LITERAL__inline:
5614.            case LITERAL___inline:
5615.            case LITERAL_virtual:
5616.            case LITERAL_explicit:
5617.            case LITERAL_friend:
5618.            case LITERAL__stdcall:
5619.            case LITERAL___stdcall:
5620.            case LITERAL__declspec:
5621.            case LITERAL___declspec:
5622.            case LITERAL_typename:
5623.            case LITERAL_auto:
5624.            case LITERAL_register:
5625.            case LITERAL_static:
5626.            case LITERAL_mutable:
5627.            case LITERAL_const:
5628.            case LITERAL_const_cast:
5629.            case LITERAL_volatile:
5630.            case LITERAL_char:
5631.            case LITERAL_wchar_t:
5632.            case LITERAL_bool:
5633.            case LITERAL_short:
5634.            case LITERAL_int:
5635.            case 44:
5636.            case 45:
5637.            case 46:
5638.            case LITERAL_long:
5639.            case LITERAL_signed:
5640.            case LITERAL_unsigned:
5641.            case LITERAL_float:
5642.            case LITERAL_double:
5643.            case LITERAL_void:
5644.            case LITERAL_class:
5645.            case LITERAL_struct:
5646.            case LITERAL_union:
5647.            case LITERAL_using:
5648.            case SCOPE:
5649.            {
5650.                break;
5651.            }
5652.            default:
5653.            {
5654.                throw new NoViableAltException(LT(1), getFilename());
5655.            }
5656.            }
5657.            }
5658.        }
5659.        
5660.        public final void ctor_head() throws RecognitionException, TokenStreamException {
5661.            
5662.            
5663.            ctor_decl_spec();
5664.            ctor_declarator();
5665.        }
5666.        
5667.        public final void ctor_body() throws RecognitionException, TokenStreamException {
5668.            
5669.            
5670.            {
5671.            switch ( LA(1)) {
5672.            case COLON:
5673.            {
5674.                ctor_initializer();
5675.                break;
5676.            }
5677.            case LCURLY:
5678.            {
5679.                break;
5680.            }
5681.            default:
5682.            {
5683.                throw new NoViableAltException(LT(1), getFilename());
5684.            }
5685.            }
5686.            }
5687.            compound_statement();
5688.        }
5689.        
5690.        public final String  qualified_ctor_id() throws RecognitionException, TokenStreamException {
5691.            String q="";
5692.            
5693.            Token  id = null;
5694.            
5695.                String so="";
5696.                String qitem="";
5697.                
5698.            
5699.            so=scope_override();
5700.            if ( inputState.guessing==0 ) {
5701.                qitem=so;
5702.            }
5703.            id = LT(1);
5704.            match(ID);
5705.            if ( inputState.guessing==0 ) {
5706.                qitem=qitem+id.getText();
5707.                     q = qitem;
5708.            }
5709.            return q;
5710.        }
5711.        
5712.        public final void ctor_initializer() throws RecognitionException, TokenStreamException {
5713.            
5714.            
5715.            match(COLON);
5716.            superclass_init();
5717.            {
5718.            _loop249:
5719.            do {
5720.                if ((LA(1)==COMMA)) {
5721.                    match(COMMA);
5722.                    superclass_init();
5723.                }
5724.                else {
5725.                    break _loop249;
5726.                }
5727.                
5728.            } while (true);
5729.            }
5730.        }
5731.        
5732.        public final void superclass_init() throws RecognitionException, TokenStreamException {
5733.            
5734.            String q="";
5735.            
5736.            q=qualified_id();
5737.            match(LPAREN);
5738.            {
5739.            switch ( LA(1)) {
5740.            case ID:
5741.            case StringLiteral:
5742.            case LITERAL__declspec:
5743.            case LITERAL___declspec:
5744.            case LPAREN:
5745.            case LITERAL_const_cast:
5746.            case LITERAL_char:
5747.            case LITERAL_wchar_t:
5748.            case LITERAL_bool:
5749.            case LITERAL_short:
5750.            case LITERAL_int:
5751.            case 44:
5752.            case 45:
5753.            case 46:
5754.            case LITERAL_long:
5755.            case LITERAL_signed:
5756.            case LITERAL_unsigned:
5757.            case LITERAL_float:
5758.            case LITERAL_double:
5759.            case LITERAL_void:
5760.            case OPERATOR:
5761.            case LITERAL_this:
5762.            case LITERAL_true:
5763.            case LITERAL_false:
5764.            case OCTALINT:
5765.            case STAR:
5766.            case AMPERSAND:
5767.            case TILDE:
5768.            case PLUS:
5769.            case MINUS:
5770.            case PLUSPLUS:
5771.            case MINUSMINUS:
5772.            case LITERAL_sizeof:
5773.            case SCOPE:
5774.            case LITERAL_dynamic_cast:
5775.            case LITERAL_static_cast:
5776.            case LITERAL_reinterpret_cast:
5777.            case NOT:
5778.            case LITERAL_new:
5779.            case LITERAL_delete:
5780.            case DECIMALINT:
5781.            case HEXADECIMALINT:
5782.            case CharLiteral:
5783.            case FLOATONE:
5784.            case FLOATTWO:
5785.            {
5786.                expression_list();
5787.                break;
5788.            }
5789.            case RPAREN:
5790.            {
5791.                break;
5792.            }
5793.            default:
5794.            {
5795.                throw new NoViableAltException(LT(1), getFilename());
5796.            }
5797.            }
5798.            }
5799.            match(RPAREN);
5800.        }
5801.        
5802.        public final void dtor_decl_spec() throws RecognitionException, TokenStreamException {
5803.            
5804.            List declSpecs = new ArrayList();
5805.            
5806.            {
5807.            _loop256:
5808.            do {
5809.                switch ( LA(1)) {
5810.                case LITERAL_inline:
5811.                case LITERAL__inline:
5812.                case LITERAL___inline:
5813.                {
5814.                    {
5815.                    switch ( LA(1)) {
5816.                    case LITERAL_inline:
5817.                    {
5818.                        match(LITERAL_inline);
5819.                        break;
5820.                    }
5821.                    case LITERAL__inline:
5822.                    {
5823.                        match(LITERAL__inline);
5824.                        break;
5825.                    }
5826.                    case LITERAL___inline:
5827.                    {
5828.                        match(LITERAL___inline);
5829.                        break;
5830.                    }
5831.                    default:
5832.                    {
5833.                        throw new NoViableAltException(LT(1), getFilename());
5834.                    }
5835.                    }
5836.                    }
5837.                    if ( inputState.guessing==0 ) {
5838.                        declSpecs.add("inline");
5839.                    }
5840.                    break;
5841.                }
5842.                case LITERAL_virtual:
5843.                {
5844.                    match(LITERAL_virtual);
5845.                    if ( inputState.guessing==0 ) {
5846.                        declSpecs.add("virtual");
5847.                    }
5848.                    break;
5849.                }
5850.                default:
5851.                {
5852.                    break _loop256;
5853.                }
5854.                }
5855.            } while (true);
5856.            }
5857.            if ( inputState.guessing==0 ) {
5858.                m.declarationSpecifiers(declSpecs);
5859.            }
5860.        }
5861.        
5862.        public final void dtor_declarator() throws RecognitionException, TokenStreamException {
5863.            
5864.            Token  id = null;
5865.            String s="";
5866.            
5867.            s=scope_override();
5868.            match(TILDE);
5869.            id = LT(1);
5870.            match(ID);
5871.            if ( inputState.guessing==0 ) {
5872.                m.dtorDeclarator(s+"~"+id.getText());
5873.            }
5874.            match(LPAREN);
5875.            match(RPAREN);
5876.            {
5877.            switch ( LA(1)) {
5878.            case LITERAL_throw:
5879.            {
5880.                exception_specification();
5881.                break;
5882.            }
5883.            case LCURLY:
5884.            case SEMICOLON:
5885.            {
5886.                break;
5887.            }
5888.            default:
5889.            {
5890.                throw new NoViableAltException(LT(1), getFilename());
5891.            }
5892.            }
5893.            }
5894.        }
5895.        
5896.        public final void parameter_declaration_list() throws RecognitionException, TokenStreamException { ...
5897.            
5898.            
5899.            {
5900.            parameter_declaration();
5901.            {
5902.            _loop265:
5903.            do {
5904.                if ((LA(1)==COMMA)) {
5905.                    match(COMMA);
5906.                    parameter_declaration();
5907.                }
5908.                else {
5909.                    break _loop265;
5910.                }
5911.                
5912.            } while (true);
5913.            }
5914.            }
5915.        }
5916.        
5917.        public final void parameter_declaration() throws RecognitionException, TokenStreamException {
5918.            
5919.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
5920.            
5921.            if ( inputState.guessing==0 ) {
5922.                m.beginParameterDeclaration();
5923.            }
5924.            {
5925.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_48.member(LA(2))))&&(!((LA(1)==SCOPE) && (LA(2)==S...
5926.                declaration_specifiers();
5927.                {
5928.                boolean synPredMatched270 = false;
5929.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5930.                    int _m270 = mark();
5931.                    synPredMatched270 = true;
5932.                    inputState.guessing++;
5933.                    try {
5934.                        {
5935.                        declarator();
5936.                        }
5937.                    }
5938.                    catch (RecognitionException pe) {
5939.                        synPredMatched270 = false;
5940.                    }
5941.                    rewind(_m270);
5942.    inputState.guessing--;
5943.                }
5944.                if ( synPredMatched270 ) {
5945.                    declarator();
5946.                }
5947.                else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
5948.                    abstract_declarator();
5949.                }
5950.                else {
5951.                    throw new NoViableAltException(LT(1), getFilename());
5952.                }
5953.                
5954.                }
5955.            }
5956.            else {
5957.                boolean synPredMatched272 = false;
5958.                if (((_tokenSet_45.member(LA(1))) && (_tokenSet_49.member(LA(2))))) {
5959.                    int _m272 = mark();
5960.                    synPredMatched272 = true;
5961.                    inputState.guessing++;
5962.                    try {
5963.                        {
5964.                        declarator();
5965.                        }
5966.                    }
5967.                    catch (RecognitionException pe) {
5968.                        synPredMatched272 = false;
5969.                    }
5970.                    rewind(_m272);
5971.    inputState.guessing--;
5972.                }
5973.                if ( synPredMatched272 ) {
5974.                    declarator();
5975.                }
5976.                else if ((LA(1)==ELLIPSIS)) {
5977.                    match(ELLIPSIS);
5978.                }
5979.                else {
5980.                    throw new NoViableAltException(LT(1), getFilename());
5981.                }
5982.                }
5983.                }
5984.                {
5985.                switch ( LA(1)) {
5986.                case ASSIGNEQUAL:
5987.                {
5988.                    match(ASSIGNEQUAL);
5989.                    remainder_expression();
5990.                    break;
5991.                }
5992.                case GREATERTHAN:
5993.                case COMMA:
5994.                case RPAREN:
5995.                case ELLIPSIS:
5996.                {
5997.                    break;
5998.                }
5999.                default:
6000.                {
6001.                    throw new NoViableAltException(LT(1), getFilename());
6002.                }
6003.                }
6004.                }
6005.                if ( inputState.guessing==0 ) {
6006.                    m.endParameterDeclaration();
6007.                }
6008.            }
6009.            
6010.        public final void abstract_declarator() throws RecognitionException, TokenStreamException {
6011.            
6012.            
6013.            switch ( LA(1)) {
6014.            case ID:
6015.            case LITERAL__stdcall:
6016.            case LITERAL___stdcall:
6017.            case STAR:
6018.            case AMPERSAND:
6019.            case SCOPE:
6020.            case LITERAL__cdecl:
6021.            case LITERAL___cdecl:
6022.            case LITERAL__near:
6023.            case LITERAL___near:
6024.            case LITERAL__far:
6025.            case LITERAL___far:
6026.            case LITERAL___interrupt:
6027.            case LITERAL_pascal:
6028.            case LITERAL__pascal:
6029.            case LITERAL___pascal:
6030.            {
6031.                ptr_operator();
6032.                abstract_declarator();
6033.                break;
6034.            }
6035.            case LPAREN:
6036.            {
6037.                match(LPAREN);
6038.                abstract_declarator();
6039.                match(RPAREN);
6040.                {
6041.                int _cnt277=0;
6042.                _loop277:
6043.                do {
6044.                    if ((LA(1)==LPAREN||LA(1)==LSQUARE)) {
6045.                        abstract_declarator_suffix();
6046.                    }
6047.                    else {
6048.                        if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename()...
6049.                    }
6050.                    
6051.                    _cnt277++;
6052.                } while (true);
6053.                }
6054.                break;
6055.            }
6056.            case LSQUARE:
6057.            {
6058.                {
6059.                int _cnt280=0;
6060.                _loop280:
6061.                do {
6062.                    if ((LA(1)==LSQUARE)) {
6063.                        match(LSQUARE);
6064.                        {
6065.                        switch ( LA(1)) {
6066.                        case ID:
6067.                        case StringLiteral:
6068.                        case LITERAL__declspec:
6069.                        case LITERAL___declspec:
6070.                        case LPAREN:
6071.                        case LITERAL_const_cast:
6072.                        case LITERAL_char:
6073.                        case LITERAL_wchar_t:
6074.                        case LITERAL_bool:
6075.                        case LITERAL_short:
6076.                        case LITERAL_int:
6077.                        case 44:
6078.                        case 45:
6079.                        case 46:
6080.                        case LITERAL_long:
6081.                        case LITERAL_signed:
6082.                        case LITERAL_unsigned:
6083.                        case LITERAL_float:
6084.                        case LITERAL_double:
6085.                        case LITERAL_void:
6086.                        case OPERATOR:
6087.                        case LITERAL_this:
6088.                        case LITERAL_true:
6089.                        case LITERAL_false:
6090.                        case OCTALINT:
6091.                        case STAR:
6092.                        case AMPERSAND:
6093.                        case TILDE:
6094.                        case PLUS:
6095.                        case MINUS:
6096.                        case PLUSPLUS:
6097.                        case MINUSMINUS:
6098.                        case LITERAL_sizeof:
6099.                        case SCOPE:
6100.                        case LITERAL_dynamic_cast:
6101.                        case LITERAL_static_cast:
6102.                        case LITERAL_reinterpret_cast:
6103.                        case NOT:
6104.                        case LITERAL_new:
6105.                        case LITERAL_delete:
6106.                        case DECIMALINT:
6107.                        case HEXADECIMALINT:
6108.                        case CharLiteral:
6109.                        case FLOATONE:
6110.                        case FLOATTWO:
6111.                        {
6112.                            constant_expression();
6113.                            break;
6114.                        }
6115.                        case RSQUARE:
6116.                        {
6117.                            break;
6118.                        }
6119.                        default:
6120.                        {
6121.                            throw new NoViableAltException(LT(1), getFilename());
6122.                        }
6123.                        }
6124.                        }
6125.                        match(RSQUARE);
6126.                    }
6127.                    else {
6128.                        if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename()...
6129.                    }
6130.                    
6131.                    _cnt280++;
6132.                } while (true);
6133.                }
6134.                break;
6135.            }
6136.            case GREATERTHAN:
6137.            case ASSIGNEQUAL:
6138.            case COMMA:
6139.            case RPAREN:
6140.            case ELLIPSIS:
6141.            {
6142.                break;
6143.            }
6144.            default:
6145.            {
6146.                throw new NoViableAltException(LT(1), getFilename());
6147.            }
6148.            }
6149.        }
6150.        
6151.        public final void type_name() throws RecognitionException, TokenStreamException {
6152.            
6153.            
6154.            declaration_specifiers();
6155.            abstract_declarator();
6156.        }
6157.        
6158.        public final void abstract_declarator_suffix() throws RecognitionException, TokenStreamException { ...
6159.            
6160.            
6161.            switch ( LA(1)) {
6162.            case LSQUARE:
6163.            {
6164.                match(LSQUARE);
6165.                {
6166.                switch ( LA(1)) {
6167.                case ID:
6168.                case StringLiteral:
6169.                case LITERAL__declspec:
6170.                case LITERAL___declspec:
6171.                case LPAREN:
6172.                case LITERAL_const_cast:
6173.                case LITERAL_char:
6174.                case LITERAL_wchar_t:
6175.                case LITERAL_bool:
6176.                case LITERAL_short:
6177.                case LITERAL_int:
6178.                case 44:
6179.                case 45:
6180.                case 46:
6181.                case LITERAL_long:
6182.                case LITERAL_signed:
6183.                case LITERAL_unsigned:
6184.                case LITERAL_float:
6185.                case LITERAL_double:
6186.                case LITERAL_void:
6187.                case OPERATOR:
6188.                case LITERAL_this:
6189.                case LITERAL_true:
6190.                case LITERAL_false:
6191.                case OCTALINT:
6192.                case STAR:
6193.                case AMPERSAND:
6194.                case TILDE:
6195.                case PLUS:
6196.                case MINUS:
6197.                case PLUSPLUS:
6198.                case MINUSMINUS:
6199.                case LITERAL_sizeof:
6200.                case SCOPE:
6201.                case LITERAL_dynamic_cast:
6202.                case LITERAL_static_cast:
6203.                case LITERAL_reinterpret_cast:
6204.                case NOT:
6205.                case LITERAL_new:
6206.                case LITERAL_delete:
6207.                case DECIMALINT:
6208.                case HEXADECIMALINT:
6209.                case CharLiteral:
6210.                case FLOATONE:
6211.                case FLOATTWO:
6212.                {
6213.                    constant_expression();
6214.                    break;
6215.                }
6216.                case RSQUARE:
6217.                {
6218.                    break;
6219.                }
6220.                default:
6221.                {
6222.                    throw new NoViableAltException(LT(1), getFilename());
6223.                }
6224.                }
6225.                }
6226.                match(RSQUARE);
6227.                break;
6228.            }
6229.            case LPAREN:
6230.            {
6231.                match(LPAREN);
6232.                {
6233.                switch ( LA(1)) {
6234.                case LITERAL_typedef:
6235.                case LITERAL_enum:
6236.                case ID:
6237.                case LITERAL_inline:
6238.                case LITERAL_extern:
6239.                case LITERAL__inline:
6240.                case LITERAL___inline:
6241.                case LITERAL_virtual:
6242.                case LITERAL_explicit:
6243.                case LITERAL_friend:
6244.                case LITERAL__stdcall:
6245.                case LITERAL___stdcall:
6246.                case LITERAL__declspec:
6247.                case LITERAL___declspec:
6248.                case LPAREN:
6249.                case LITERAL_typename:
6250.                case LITERAL_auto:
6251.                case LITERAL_register:
6252.                case LITERAL_static:
6253.                case LITERAL_mutable:
6254.                case LITERAL_const:
6255.                case LITERAL_const_cast:
6256.                case LITERAL_volatile:
6257.                case LITERAL_char:
6258.                case LITERAL_wchar_t:
6259.                case LITERAL_bool:
6260.                case LITERAL_short:
6261.                case LITERAL_int:
6262.                case 44:
6263.                case 45:
6264.                case 46:
6265.                case LITERAL_long:
6266.                case LITERAL_signed:
6267.                case LITERAL_unsigned:
6268.                case LITERAL_float:
6269.                case LITERAL_double:
6270.                case LITERAL_void:
6271.                case LITERAL_class:
6272.                case LITERAL_struct:
6273.                case LITERAL_union:
6274.                case OPERATOR:
6275.                case LITERAL_this:
6276.                case LITERAL_true:
6277.                case LITERAL_false:
6278.                case STAR:
6279.                case AMPERSAND:
6280.                case TILDE:
6281.                case ELLIPSIS:
6282.                case SCOPE:
6283.                case LITERAL__cdecl:
6284.                case LITERAL___cdecl:
6285.                case LITERAL__near:
6286.                case LITERAL___near:
6287.                case LITERAL__far:
6288.                case LITERAL___far:
6289.                case LITERAL___interrupt:
6290.                case LITERAL_pascal:
6291.                case LITERAL__pascal:
6292.                case LITERAL___pascal:
6293.                {
6294.                    parameter_list();
6295.                    break;
6296.                }
6297.                case RPAREN:
6298.                {
6299.                    break;
6300.                }
6301.                default:
6302.                {
6303.                    throw new NoViableAltException(LT(1), getFilename());
6304.                }
6305.                }
6306.                }
6307.                match(RPAREN);
6308.                cv_qualifier_seq();
6309.                {
6310.                switch ( LA(1)) {
6311.                case LITERAL_throw:
6312.                {
6313.                    exception_specification();
6314.                    break;
6315.                }
6316.                case GREATERTHAN:
6317.                case ASSIGNEQUAL:
6318.                case COMMA:
6319.                case LPAREN:
6320.                case RPAREN:
6321.                case LSQUARE:
6322.                case ELLIPSIS:
6323.                {
6324.                    break;
6325.                }
6326.                default:
6327.                {
6328.                    throw new NoViableAltException(LT(1), getFilename());
6329.                }
6330.                }
6331.                }
6332.                break;
6333.            }
6334.            default:
6335.            {
6336.                throw new NoViableAltException(LT(1), getFilename());
6337.            }
6338.            }
6339.        }
6340.        
6341.        public final void template_parameter() throws RecognitionException, TokenStreamException {
6342.            
6343.            Token  id = null;
6344.            
6345.            {
6346.            if ((LA(1)==LITERAL_typename||LA(1)==LITERAL_class) && (_tokenSet_52.member(LA(2)))) {
6347.                {
6348.                switch ( LA(1)) {
6349.                case LITERAL_class:
6350.                {
6351.                    match(LITERAL_class);
6352.                    break;
6353.                }
6354.                case LITERAL_typename:
6355.                {
6356.                    match(LITERAL_typename);
6357.                    break;
6358.                }
6359.                default:
6360.                {
6361.                    throw new NoViableAltException(LT(1), getFilename());
6362.                }
6363.                }
6364.                }
6365.                {
6366.                switch ( LA(1)) {
6367.                case ID:
6368.                {
6369.                    id = LT(1);
6370.                    match(ID);
6371.                    {
6372.                    switch ( LA(1)) {
6373.                    case ASSIGNEQUAL:
6374.                    {
6375.                        match(ASSIGNEQUAL);
6376.                        assigned_type_name();
6377.                        break;
6378.                    }
6379.                    case GREATERTHAN:
6380.                    case COMMA:
6381.                    {
6382.                        break;
6383.                    }
6384.                    default:
6385.                    {
6386.                        throw new NoViableAltException(LT(1), getFilename());
6387.                    }
6388.                    }
6389.                    }
6390.                    break;
6391.                }
6392.                case GREATERTHAN:
6393.                case COMMA:
6394.                {
6395.                    break;
6396.                }
6397.                default:
6398.                {
6399.                    throw new NoViableAltException(LT(1), getFilename());
6400.                }
6401.                }
6402.                }
6403.                if ( inputState.guessing==0 ) {
6404.                        if(!symbols.containsKey(id.getText()))
6405.                                    symbols.put(id.getText(),CPPvariables.OT_TYPE_DEF);
6406.                            
6407.                }
6408.            }
6409.            else if ((_tokenSet_53.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
6410.                parameter_declaration();
6411.            }
6412.            else {
6413.                throw new NoViableAltException(LT(1), getFilename());
6414.            }
6415.            
6416.            }
6417.        }
6418.        
6419.        public final void assigned_type_name() throws RecognitionException, TokenStreamException {
6420.            
6421.            String s="";
6422.            
6423.            {
6424.            if ((LA(1)==ID||LA(1)==SCOPE) && (_tokenSet_54.member(LA(2)))) {
6425.                s=qualified_type();
6426.                abstract_declarator();
6427.            }
6428.            else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
6429.                simple_type_specifier();
6430.                abstract_declarator();
6431.            }
6432.            else {
6433.                throw new NoViableAltException(LT(1), getFilename());
6434.            }
6435.            
6436.            }
6437.        }
6438.        
6439.        public final void template_id() throws RecognitionException, TokenStreamException {
6440.            
6441.            
6442.            match(ID);
6443.            match(LESSTHAN);
6444.            template_argument_list();
6445.            match(GREATERTHAN);
6446.        }
6447.        
6448.        public final void template_argument() throws RecognitionException, TokenStreamException {
6449.            
6450.            java.util.BitSet auxBitSet=(java.util.BitSet)CPPvariables.QI_TYPE.clone(); auxBitSet.or(CPPvariabl...
6451.            
6452.            if (((_tokenSet_11.member(LA(1))) && (_tokenSet_57.member(LA(2))))&&(( !(LA(1)==SCOPE||LA(1)==ID) ...
6453.                type_name();
6454.            }
6455.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_58.member(LA(2)))) {
6456.                shift_expression();
6457.            }
6458.            else {
6459.                throw new NoViableAltException(LT(1), getFilename());
6460.            }
6461.            
6462.        }
6463.        
6464.        public final void shift_expression() throws RecognitionException, TokenStreamException {
6465.            
6466.            
6467.            additive_expression();
6468.            {
6469.            _loop385:
6470.            do {
6471.                if ((LA(1)==SHIFTLEFT||LA(1)==SHIFTRIGHT)) {
6472.                    {
6473.                    switch ( LA(1)) {
6474.                    case SHIFTLEFT:
6475.                    {
6476.                        match(SHIFTLEFT);
6477.                        break;
6478.                    }
6479.                    case SHIFTRIGHT:
6480.                    {
6481.                        match(SHIFTRIGHT);
6482.                        break;
6483.                    }
6484.                    default:
6485.                    {
6486.                        throw new NoViableAltException(LT(1), getFilename());
6487.                    }
6488.                    }
6489.                    }
6490.                    additive_expression();
6491.                }
6492.                else {
6493.                    break _loop385;
6494.                }
6495.                
6496.            } while (true);
6497.            }
6498.        }
6499.        
6500.        public final void statement_list() throws RecognitionException, TokenStreamException {
6501.            
6502.            
6503.            {
6504.            int _cnt308=0;
6505.            _loop308:
6506.            do {
6507.                if ((_tokenSet_59.member(LA(1)))) {
6508.                    statement();
6509.                }
6510.                else {
6511.                    if ( _cnt308>=1 ) { break _loop308; } else {throw new NoViableAltException(LT(1), getFilename())...
6512.                }
6513.                
6514.                _cnt308++;
6515.            } while (true);
6516.            }
6517.        }
6518.        
6519.        public final void statement() throws RecognitionException, TokenStreamException {
6520.            
6521.            
6522.            {
6523.            switch ( LA(1)) {
6524.            case LITERAL_case:
6525.            {
6526.                case_statement();
6527.                break;
6528.            }
6529.            case LITERAL_default:
6530.            {
6531.                default_statement();
6532.                break;
6533.            }
6534.            case LCURLY:
6535.            {
6536.                compound_statement();
6537.                break;
6538.            }
6539.            case LITERAL_if:
6540.            case LITERAL_switch:
6541.            {
6542.                selection_statement();
6543.                break;
6544.            }
6545.            case LITERAL_while:
6546.            case LITERAL_do:
6547.            case LITERAL_for:
6548.            {
6549.                iteration_statement();
6550.                break;
6551.            }
6552.            case LITERAL_goto:
6553.            case LITERAL_continue:
6554.            case LITERAL_break:
6555.            case LITERAL_return:
6556.            {
6557.                jump_statement();
6558.                break;
6559.            }
6560.            case SEMICOLON:
6561.            {
6562.                match(SEMICOLON);
6563.                break;
6564.            }
6565.            case LITERAL_try:
6566.            {
6567.                try_block();
6568.                break;
6569.            }
6570.            case LITERAL_throw:
6571.            {
6572.                throw_statement();
6573.                break;
6574.            }
6575.            case LITERAL__asm:
6576.            case LITERAL___asm:
6577.            {
6578.                asm_block();
6579.                break;
6580.            }
6581.            default:
6582.                boolean synPredMatched312 = false;
6583.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6584.                    int _m312 = mark();
6585.                    synPredMatched312 = true;
6586.                    inputState.guessing++;
6587.                    try {
6588.                        {
6589.                        declaration();
6590.                        }
6591.                    }
6592.                    catch (RecognitionException pe) {
6593.                        synPredMatched312 = false;
6594.                    }
6595.                    rewind(_m312);
6596.    inputState.guessing--;
6597.                }
6598.                if ( synPredMatched312 ) {
6599.                    declaration();
6600.                }
6601.                else if ((LA(1)==ID) && (LA(2)==COLON)) {
6602.                    labeled_statement();
6603.                }
6604.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6605.                    expression();
6606.                    match(SEMICOLON);
6607.                }
6608.            else {
6609.                throw new NoViableAltException(LT(1), getFilename());
6610.            }
6611.            }
6612.            }
6613.        }
6614.        
6615.        public final void labeled_statement() throws RecognitionException, TokenStreamException {
6616.            
6617.            
6618.            match(ID);
6619.            match(COLON);
6620.            statement();
6621.        }
6622.        
6623.        public final void case_statement() throws RecognitionException, TokenStreamException {
6624.            
6625.            
6626.            match(LITERAL_case);
6627.            constant_expression();
6628.            match(COLON);
6629.            statement();
6630.        }
6631.        
6632.        public final void default_statement() throws RecognitionException, TokenStreamException {
6633.            
6634.            
6635.            match(LITERAL_default);
6636.            match(COLON);
6637.            statement();
6638.        }
6639.        
6640.        public final void expression() throws RecognitionException, TokenStreamException {
6641.            
6642.            
6643.            assignment_expression();
6644.            {
6645.            _loop347:
6646.            do {
6647.                if ((LA(1)==COMMA)) {
6648.                    match(COMMA);
6649.                    assignment_expression();
6650.                }
6651.                else {
6652.                    break _loop347;
6653.                }
6654.                
6655.            } while (true);
6656.            }
6657.        }
6658.        
6659.        public final void selection_statement() throws RecognitionException, TokenStreamException {
6660.            
6661.            
6662.            switch ( LA(1)) {
6663.            case LITERAL_if:
6664.            {
6665.                match(LITERAL_if);
6666.                match(LPAREN);
6667.                expression();
6668.                match(RPAREN);
6669.                statement();
6670.                {
6671.                if ((LA(1)==LITERAL_else) && (_tokenSet_59.member(LA(2)))) {
6672.                    match(LITERAL_else);
6673.                    statement();
6674.                }
6675.                else if ((_tokenSet_61.member(LA(1))) && (_tokenSet_62.member(LA(2)))) {
6676.                }
6677.                else {
6678.                    throw new NoViableAltException(LT(1), getFilename());
6679.                }
6680.                
6681.                }
6682.                break;
6683.            }
6684.            case LITERAL_switch:
6685.            {
6686.                match(LITERAL_switch);
6687.                match(LPAREN);
6688.                expression();
6689.                match(RPAREN);
6690.                statement();
6691.                break;
6692.            }
6693.            default:
6694.            {
6695.                throw new NoViableAltException(LT(1), getFilename());
6696.            }
6697.            }
6698.        }
6699.        
6700.        public final void iteration_statement() throws RecognitionException, TokenStreamException {
6701.            
6702.            
6703.            switch ( LA(1)) {
6704.            case LITERAL_while:
6705.            {
6706.                match(LITERAL_while);
6707.                match(LPAREN);
6708.                expression();
6709.                match(RPAREN);
6710.                statement();
6711.                break;
6712.            }
6713.            case LITERAL_do:
6714.            {
6715.                match(LITERAL_do);
6716.                statement();
6717.                match(LITERAL_while);
6718.                match(LPAREN);
6719.                expression();
6720.                match(RPAREN);
6721.                match(SEMICOLON);
6722.                break;
6723.            }
6724.            case LITERAL_for:
6725.            {
6726.                match(LITERAL_for);
6727.                match(LPAREN);
6728.                {
6729.                boolean synPredMatched323 = false;
6730.                if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
6731.                    int _m323 = mark();
6732.                    synPredMatched323 = true;
6733.                    inputState.guessing++;
6734.                    try {
6735.                        {
6736.                        declaration();
6737.                        }
6738.                    }
6739.                    catch (RecognitionException pe) {
6740.                        synPredMatched323 = false;
6741.                    }
6742.                    rewind(_m323);
6743.    inputState.guessing--;
6744.                }
6745.                if ( synPredMatched323 ) {
6746.                    declaration();
6747.                }
6748.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
6749.                    expression();
6750.                    match(SEMICOLON);
6751.                }
6752.                else if ((LA(1)==SEMICOLON)) {
6753.                    match(SEMICOLON);
6754.                }
6755.                else {
6756.                    throw new NoViableAltException(LT(1), getFilename());
6757.                }
6758.                
6759.                }
6760.                {
6761.                switch ( LA(1)) {
6762.                case ID:
6763.                case StringLiteral:
6764.                case LITERAL__declspec:
6765.                case LITERAL___declspec:
6766.                case LPAREN:
6767.                case LITERAL_const_cast:
6768.                case LITERAL_char:
6769.                case LITERAL_wchar_t:
6770.                case LITERAL_bool:
6771.                case LITERAL_short:
6772.                case LITERAL_int:
6773.                case 44:
6774.                case 45:
6775.                case 46:
6776.                case LITERAL_long:
6777.                case LITERAL_signed:
6778.                case LITERAL_unsigned:
6779.                case LITERAL_float:
6780.                case LITERAL_double:
6781.                case LITERAL_void:
6782.                case OPERATOR:
6783.                case LITERAL_this:
6784.                case LITERAL_true:
6785.                case LITERAL_false:
6786.                case OCTALINT:
6787.                case STAR:
6788.                case AMPERSAND:
6789.                case TILDE:
6790.                case PLUS:
6791.                case MINUS:
6792.                case PLUSPLUS:
6793.                case MINUSMINUS:
6794.                case LITERAL_sizeof:
6795.                case SCOPE:
6796.                case LITERAL_dynamic_cast:
6797.                case LITERAL_static_cast:
6798.                case LITERAL_reinterpret_cast:
6799.                case NOT:
6800.                case LITERAL_new:
6801.                case LITERAL_delete:
6802.                case DECIMALINT:
6803.                case HEXADECIMALINT:
6804.                case CharLiteral:
6805.                case FLOATONE:
6806.                case FLOATTWO:
6807.                {
6808.                    expression();
6809.                    break;
6810.                }
6811.                case SEMICOLON:
6812.                {
6813.                    break;
6814.                }
6815.                default:
6816.                {
6817.                    throw new NoViableAltException(LT(1), getFilename());
6818.                }
6819.                }
6820.                }
6821.                match(SEMICOLON);
6822.                {
6823.                switch ( LA(1)) {
6824.                case ID:
6825.                case StringLiteral:
6826.                case LITERAL__declspec:
6827.                case LITERAL___declspec:
6828.                case LPAREN:
6829.                case LITERAL_const_cast:
6830.                case LITERAL_char:
6831.                case LITERAL_wchar_t:
6832.                case LITERAL_bool:
6833.                case LITERAL_short:
6834.                case LITERAL_int:
6835.                case 44:
6836.                case 45:
6837.                case 46:
6838.                case LITERAL_long:
6839.                case LITERAL_signed:
6840.                case LITERAL_unsigned:
6841.                case LITERAL_float:
6842.                case LITERAL_double:
6843.                case LITERAL_void:
6844.                case OPERATOR:
6845.                case LITERAL_this:
6846.                case LITERAL_true:
6847.                case LITERAL_false:
6848.                case OCTALINT:
6849.                case STAR:
6850.                case AMPERSAND:
6851.                case TILDE:
6852.                case PLUS:
6853.                case MINUS:
6854.                case PLUSPLUS:
6855.                case MINUSMINUS:
6856.                case LITERAL_sizeof:
6857.                case SCOPE:
6858.                case LITERAL_dynamic_cast:
6859.                case LITERAL_static_cast:
6860.                case LITERAL_reinterpret_cast:
6861.                case NOT:
6862.                case LITERAL_new:
6863.                case LITERAL_delete:
6864.                case DECIMALINT:
6865.                case HEXADECIMALINT:
6866.                case CharLiteral:
6867.                case FLOATONE:
6868.                case FLOATTWO:
6869.                {
6870.                    expression();
6871.                    break;
6872.                }
6873.                case RPAREN:
6874.                {
6875.                    break;
6876.                }
6877.                default:
6878.                {
6879.                    throw new NoViableAltException(LT(1), getFilename());
6880.                }
6881.                }
6882.                }
6883.                match(RPAREN);
6884.                statement();
6885.                break;
6886.            }
6887.            default:
6888.            {
6889.                throw new NoViableAltException(LT(1), getFilename());
6890.            }
6891.            }
6892.        }
6893.        
6894.        public final void jump_statement() throws RecognitionException, TokenStreamException {
6895.            
6896.            
6897.            {
6898.            switch ( LA(1)) {
6899.            case LITERAL_goto:
6900.            {
6901.                match(LITERAL_goto);
6902.                match(ID);
6903.                match(SEMICOLON);
6904.                break;
6905.            }
6906.            case LITERAL_continue:
6907.            {
6908.                match(LITERAL_continue);
6909.                match(SEMICOLON);
6910.                break;
6911.            }
6912.            case LITERAL_break:
6913.            {
6914.                match(LITERAL_break);
6915.                match(SEMICOLON);
6916.                break;
6917.            }
6918.            case LITERAL_return:
6919.            {
6920.                match(LITERAL_return);
6921.                {
6922.                boolean synPredMatched330 = false;
6923.                if (((LA(1)==LPAREN) && (LA(2)==ID))) {
6924.                    int _m330 = mark();
6925.                    synPredMatched330 = true;
6926.                    inputState.guessing++;
6927.                    try {
6928.                        {
6929.                        match(LPAREN);
6930.                        if (!((qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )))
6931.                          throw new SemanticException("(qualifiedItemIsOneOf(CPPvariables.QI_TYPE,0) )");
6932.                        match(ID);
6933.                        match(RPAREN);
6934.                        }
6935.                    }
6936.                    catch (RecognitionException pe) {
6937.                        synPredMatched330 = false;
6938.                    }
6939.                    rewind(_m330);
6940.    inputState.guessing--;
6941.                }
6942.                if ( synPredMatched330 ) {
6943.                    match(LPAREN);
6944.                    match(ID);
6945.                    match(RPAREN);
6946.                    {
6947.                    switch ( LA(1)) {
6948.                    case ID:
6949.                    case StringLiteral:
6950.                    case LITERAL__declspec:
6951.                    case LITERAL___declspec:
6952.                    case LPAREN:
6953.                    case LITERAL_const_cast:
6954.                    case LITERAL_char:
6955.                    case LITERAL_wchar_t:
6956.                    case LITERAL_bool:
6957.                    case LITERAL_short:
6958.                    case LITERAL_int:
6959.                    case 44:
6960.                    case 45:
6961.                    case 46:
6962.                    case LITERAL_long:
6963.                    case LITERAL_signed:
6964.                    case LITERAL_unsigned:
6965.                    case LITERAL_float:
6966.                    case LITERAL_double:
6967.                    case LITERAL_void:
6968.                    case OPERATOR:
6969.                    case LITERAL_this:
6970.                    case LITERAL_true:
6971.                    case LITERAL_false:
6972.                    case OCTALINT:
6973.                    case STAR:
6974.                    case AMPERSAND:
6975.                    case TILDE:
6976.                    case PLUS:
6977.                    case MINUS:
6978.                    case PLUSPLUS:
6979.                    case MINUSMINUS:
6980.                    case LITERAL_sizeof:
6981.                    case SCOPE:
6982.                    case LITERAL_dynamic_cast:
6983.                    case LITERAL_static_cast:
6984.                    case LITERAL_reinterpret_cast:
6985.                    case NOT:
6986.                    case LITERAL_new:
6987.                    case LITERAL_delete:
6988.                    case DECIMALINT:
6989.                    case HEXADECIMALINT:
6990.                    case CharLiteral:
6991.                    case FLOATONE:
6992.                    case FLOATTWO:
6993.                    {
6994.                        expression();
6995.                        break;
6996.                    }
6997.                    case SEMICOLON:
6998.                    {
6999.                        break;
7000.                    }
7001.                    default:
7002.                    {
7003.                        throw new NoViableAltException(LT(1), getFilename());
7004.                    }
7005.                    }
7006.                    }
7007.                }
7008.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_60.member(LA(2)))) {
7009.                    expression();
7010.                }
7011.                else if ((LA(1)==SEMICOLON)) {
7012.                }
7013.                else {
7014.                    throw new NoViableAltException(LT(1), getFilename());
7015.                }
7016.                
7017.                }
7018.                match(SEMICOLON);
7019.                break;
7020.            }
7021.            default:
7022.            {
7023.                throw new NoViableAltException(LT(1), getFilename());
7024.            }
7025.            }
7026.            }
7027.        }
7028.        
7029.        public final void try_block() throws RecognitionException, TokenStreamException {
7030.            
7031.            
7032.            match(LITERAL_try);
7033.            compound_statement();
7034.            {
7035.            _loop334:
7036.            do {
7037.                if ((LA(1)==LITERAL_catch)) {
7038.                    handler();
7039.                }
7040.                else {
7041.                    break _loop334;
7042.                }
7043.                
7044.            } while (true);
7045.            }
7046.        }
7047.        
7048.        public final void throw_statement() throws RecognitionException, TokenStreamException {
7049.            
7050.            
7051.            match(LITERAL_throw);
7052.            {
7053.            switch ( LA(1)) {
7054.            case ID:
7055.            case StringLiteral:
7056.            case LITERAL__declspec:
7057.            case LITERAL___declspec:
7058.            case LPAREN:
7059.            case LITERAL_const_cast:
7060.            case LITERAL_char:
7061.            case LITERAL_wchar_t:
7062.            case LITERAL_bool:
7063.            case LITERAL_short:
7064.            case LITERAL_int:
7065.            case 44:
7066.            case 45:
7067.            case 46:
7068.            case LITERAL_long:
7069.            case LITERAL_signed:
7070.            case LITERAL_unsigned:
7071.            case LITERAL_float:
7072.            case LITERAL_double:
7073.            case LITERAL_void:
7074.            case OPERATOR:
7075.            case LITERAL_this:
7076.            case LITERAL_true:
7077.            case LITERAL_false:
7078.            case OCTALINT:
7079.            case STAR:
7080.            case AMPERSAND:
7081.            case TILDE:
7082.            case PLUS:
7083.            case MINUS:
7084.            case PLUSPLUS:
7085.            case MINUSMINUS:
7086.            case LITERAL_sizeof:
7087.            case SCOPE:
7088.            case LITERAL_dynamic_cast:
7089.            case LITERAL_static_cast:
7090.            case LITERAL_reinterpret_cast:
7091.            case NOT:
7092.            case LITERAL_new:
7093.            case LITERAL_delete:
7094.            case DECIMALINT:
7095.            case HEXADECIMALINT:
7096.            case CharLiteral:
7097.            case FLOATONE:
7098.            case FLOATTWO:
7099.            {
7100.                assignment_expression();
7101.                break;
7102.            }
7103.            case SEMICOLON:
7104.            {
7105.                break;
7106.            }
7107.            default:
7108.            {
7109.                throw new NoViableAltException(LT(1), getFilename());
7110.            }
7111.            }
7112.            }
7113.            match(SEMICOLON);
7114.        }
7115.        
7116.        public final void asm_block() throws RecognitionException, TokenStreamException {
7117.            
7118.            
7119.            {
7120.            switch ( LA(1)) {
7121.            case LITERAL__asm:
7122.            {
7123.                match(LITERAL__asm);
7124.                break;
7125.            }
7126.            case LITERAL___asm:
7127.            {
7128.                match(LITERAL___asm);
7129.                break;
7130.            }
7131.            default:
7132.            {
7133.                throw new NoViableAltException(LT(1), getFilename());
7134.            }
7135.            }
7136.            }
7137.            match(LCURLY);
7138.            {
7139.            _loop344:
7140.            do {
7141.                if ((_tokenSet_63.member(LA(1)))) {
7142.                    matchNot(RCURLY);
7143.                }
7144.                else {
7145.                    break _loop344;
7146.                }
7147.                
7148.            } while (true);
7149.            }
7150.            match(RCURLY);
7151.        }
7152.        
7153.        public final void handler() throws RecognitionException, TokenStreamException {
7154.            
7155.            
7156.            match(LITERAL_catch);
7157.            match(LPAREN);
7158.            exception_declaration();
7159.            match(RPAREN);
7160.            compound_statement();
7161.        }
7162.        
7163.        public final void exception_declaration() throws RecognitionException, TokenStreamException {
7164.            
7165.            
7166.            parameter_declaration_list();
7167.        }
7168.        
7169.        public final void assignment_expression() throws RecognitionException, TokenStreamException {
7170.            
7171.            
7172.            conditional_expression();
7173.            {
7174.            switch ( LA(1)) {
7175.            case ASSIGNEQUAL:
7176.            case TIMESEQUAL:
7177.            case DIVIDEEQUAL:
7178.            case MINUSEQUAL:
7179.            case PLUSEQUAL:
7180.            case MODEQUAL:
7181.            case SHIFTLEFTEQUAL:
7182.            case SHIFTRIGHTEQUAL:
7183.            case BITWISEANDEQUAL:
7184.            case BITWISEXOREQUAL:
7185.            case BITWISEOREQUAL:
7186.            {
7187.                {
7188.                switch ( LA(1)) {
7189.                case ASSIGNEQUAL:
7190.                {
7191.                    match(ASSIGNEQUAL);
7192.                    break;
7193.                }
7194.                case TIMESEQUAL:
7195.                {
7196.                    match(TIMESEQUAL);
7197.                    break;
7198.                }
7199.                case DIVIDEEQUAL:
7200.                {
7201.                    match(DIVIDEEQUAL);
7202.                    break;
7203.                }
7204.                case MINUSEQUAL:
7205.                {
7206.                    match(MINUSEQUAL);
7207.                    break;
7208.                }
7209.                case PLUSEQUAL:
7210.                {
7211.                    match(PLUSEQUAL);
7212.                    break;
7213.                }
7214.                case MODEQUAL:
7215.                {
7216.                    match(MODEQUAL);
7217.                    break;
7218.                }
7219.                case SHIFTLEFTEQUAL:
7220.                {
7221.                    match(SHIFTLEFTEQUAL);
7222.                    break;
7223.                }
7224.                case SHIFTRIGHTEQUAL:
7225.                {
7226.                    match(SHIFTRIGHTEQUAL);
7227.                    break;
7228.                }
7229.                case BITWISEANDEQUAL:
7230.                {
7231.                    match(BITWISEANDEQUAL);
7232.                    break;
7233.                }
7234.                case BITWISEXOREQUAL:
7235.                {
7236.                    match(BITWISEXOREQUAL);
7237.                    break;
7238.                }
7239.                case BITWISEOREQUAL:
7240.                {
7241.                    match(BITWISEOREQUAL);
7242.                    break;
7243.                }
7244.                default:
7245.                {
7246.                    throw new NoViableAltException(LT(1), getFilename());
7247.                }
7248.                }
7249.                }
7250.                remainder_expression();
7251.                break;
7252.            }
7253.            case GREATERTHAN:
7254.            case SEMICOLON:
7255.            case RCURLY:
7256.            case COLON:
7257.            case COMMA:
7258.            case RPAREN:
7259.            case RSQUARE:
7260.            case ELLIPSIS:
7261.            {
7262.                break;
7263.            }
7264.            default:
7265.            {
7266.                throw new NoViableAltException(LT(1), getFilename());
7267.            }
7268.            }
7269.            }
7270.        }
7271.        
7272.        public final void conditional_expression() throws RecognitionException, TokenStreamException {
7273.            
7274.            
7275.            logical_or_expression();
7276.            {
7277.            switch ( LA(1)) {
7278.            case QUESTIONMARK:
7279.            {
7280.                match(QUESTIONMARK);
7281.                expression();
7282.                match(COLON);
7283.                conditional_expression();
7284.                break;
7285.            }
7286.            case GREATERTHAN:
7287.            case SEMICOLON:
7288.            case RCURLY:
7289.            case ASSIGNEQUAL:
7290.            case COLON:
7291.            case COMMA:
7292.            case RPAREN:
7293.            case RSQUARE:
7294.            case ELLIPSIS:
7295.            case TIMESEQUAL:
7296.            case DIVIDEEQUAL:
7297.            case MINUSEQUAL:
7298.            case PLUSEQUAL:
7299.            case MODEQUAL:
7300.            case SHIFTLEFTEQUAL:
7301.            case SHIFTRIGHTEQUAL:
7302.            case BITWISEANDEQUAL:
7303.            case BITWISEXOREQUAL:
7304.            case BITWISEOREQUAL:
7305.            {
7306.                break;
7307.            }
7308.            default:
7309.            {
7310.                throw new NoViableAltException(LT(1), getFilename());
7311.            }
7312.            }
7313.            }
7314.        }
7315.        
7316.        public final void logical_or_expression() throws RecognitionException, TokenStreamException {
7317.            
7318.            
7319.            logical_and_expression();
7320.            {
7321.            _loop361:
7322.            do {
7323.                if ((LA(1)==OR)) {
7324.                    match(OR);
7325.                    logical_and_expression();
7326.                }
7327.                else {
7328.                    break _loop361;
7329.                }
7330.                
7331.            } while (true);
7332.            }
7333.        }
7334.        
7335.        public final void logical_and_expression() throws RecognitionException, TokenStreamException {
7336.            
7337.            
7338.            inclusive_or_expression();
7339.            {
7340.            _loop364:
7341.            do {
7342.                if ((LA(1)==AND)) {
7343.                    match(AND);
7344.                    inclusive_or_expression();
7345.                }
7346.                else {
7347.                    break _loop364;
7348.                }
7349.                
7350.            } while (true);
7351.            }
7352.        }
7353.        
7354.        public final void inclusive_or_expression() throws RecognitionException, TokenStreamException {
7355.            
7356.            
7357.            exclusive_or_expression();
7358.            {
7359.            _loop367:
7360.            do {
7361.                if ((LA(1)==BITWISEOR)) {
7362.                    match(BITWISEOR);
7363.                    exclusive_or_expression();
7364.                }
7365.                else {
7366.                    break _loop367;
7367.                }
7368.                
7369.            } while (true);
7370.            }
7371.        }
7372.        
7373.        public final void exclusive_or_expression() throws RecognitionException, TokenStreamException {
7374.            
7375.            
7376.            and_expression();
7377.            {
7378.            _loop370:
7379.            do {
7380.                if ((LA(1)==BITWISEXOR)) {
7381.                    match(BITWISEXOR);
7382.                    and_expression();
7383.                }
7384.                else {
7385.                    break _loop370;
7386.                }
7387.                
7388.            } while (true);
7389.            }
7390.        }
7391.        
7392.        public final void and_expression() throws RecognitionException, TokenStreamException {
7393.            
7394.            
7395.            equality_expression();
7396.            {
7397.            _loop373:
7398.            do {
7399.                if ((LA(1)==AMPERSAND)) {
7400.                    match(AMPERSAND);
7401.                    equality_expression();
7402.                }
7403.                else {
7404.                    break _loop373;
7405.                }
7406.                
7407.            } while (true);
7408.            }
7409.        }
7410.        
7411.        public final void equality_expression() throws RecognitionException, TokenStreamException {
7412.            
7413.            
7414.            relational_expression();
7415.            {
7416.            _loop377:
7417.            do {
7418.                if ((LA(1)==NOTEQUAL||LA(1)==EQUAL)) {
7419.                    {
7420.                    switch ( LA(1)) {
7421.                    case NOTEQUAL:
7422.                    {
7423.                        match(NOTEQUAL);
7424.                        break;
7425.                    }
7426.                    case EQUAL:
7427.                    {
7428.                        match(EQUAL);
7429.                        break;
7430.                    }
7431.                    default:
7432.                    {
7433.                        throw new NoViableAltException(LT(1), getFilename());
7434.                    }
7435.                    }
7436.                    }
7437.                    relational_expression();
7438.                }
7439.                else {
7440.                    break _loop377;
7441.                }
7442.                
7443.            } while (true);
7444.            }
7445.        }
7446.        
7447.        public final void relational_expression() throws RecognitionException, TokenStreamException {
7448.            
7449.            
7450.            shift_expression();
7451.            {
7452.            _loop381:
7453.            do {
7454.                if ((_tokenSet_64.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7455.                    {
7456.                    switch ( LA(1)) {
7457.                    case LESSTHAN:
7458.                    {
7459.                        match(LESSTHAN);
7460.                        break;
7461.                    }
7462.                    case GREATERTHAN:
7463.                    {
7464.                        match(GREATERTHAN);
7465.                        break;
7466.                    }
7467.                    case LESSTHANOREQUALTO:
7468.                    {
7469.                        match(LESSTHANOREQUALTO);
7470.                        break;
7471.                    }
7472.                    case GREATERTHANOREQUALTO:
7473.                    {
7474.                        match(GREATERTHANOREQUALTO);
7475.                        break;
7476.                    }
7477.                    default:
7478.                    {
7479.                        throw new NoViableAltException(LT(1), getFilename());
7480.                    }
7481.                    }
7482.                    }
7483.                    shift_expression();
7484.                }
7485.                else {
7486.                    break _loop381;
7487.                }
7488.                
7489.            } while (true);
7490.            }
7491.        }
7492.        
7493.        public final void additive_expression() throws RecognitionException, TokenStreamException {
7494.            
7495.            
7496.            multiplicative_expression();
7497.            {
7498.            _loop389:
7499.            do {
7500.                if ((LA(1)==PLUS||LA(1)==MINUS)) {
7501.                    {
7502.                    switch ( LA(1)) {
7503.                    case PLUS:
7504.                    {
7505.                        match(PLUS);
7506.                        break;
7507.                    }
7508.                    case MINUS:
7509.                    {
7510.                        match(MINUS);
7511.                        break;
7512.                    }
7513.                    default:
7514.                    {
7515.                        throw new NoViableAltException(LT(1), getFilename());
7516.                    }
7517.                    }
7518.                    }
7519.                    multiplicative_expression();
7520.                }
7521.                else {
7522.                    break _loop389;
7523.                }
7524.                
7525.            } while (true);
7526.            }
7527.        }
7528.        
7529.        public final void multiplicative_expression() throws RecognitionException, TokenStreamException {
7530.            
7531.            
7532.            pm_expression();
7533.            {
7534.            _loop393:
7535.            do {
7536.                if ((_tokenSet_65.member(LA(1)))) {
7537.                    {
7538.                    switch ( LA(1)) {
7539.                    case STAR:
7540.                    {
7541.                        match(STAR);
7542.                        break;
7543.                    }
7544.                    case DIVIDE:
7545.                    {
7546.                        match(DIVIDE);
7547.                        break;
7548.                    }
7549.                    case MOD:
7550.                    {
7551.                        match(MOD);
7552.                        break;
7553.                    }
7554.                    default:
7555.                    {
7556.                        throw new NoViableAltException(LT(1), getFilename());
7557.                    }
7558.                    }
7559.                    }
7560.                    pm_expression();
7561.                }
7562.                else {
7563.                    break _loop393;
7564.                }
7565.                
7566.            } while (true);
7567.            }
7568.        }
7569.        
7570.        public final void pm_expression() throws RecognitionException, TokenStreamException {
7571.            
7572.            
7573.            cast_expression();
7574.            {
7575.            _loop397:
7576.            do {
7577.                if ((LA(1)==DOTMBR||LA(1)==POINTERTOMBR)) {
7578.                    {
7579.                    switch ( LA(1)) {
7580.                    case DOTMBR:
7581.                    {
7582.                        match(DOTMBR);
7583.                        break;
7584.                    }
7585.                    case POINTERTOMBR:
7586.                    {
7587.                        match(POINTERTOMBR);
7588.                        break;
7589.                    }
7590.                    default:
7591.                    {
7592.                        throw new NoViableAltException(LT(1), getFilename());
7593.                    }
7594.                    }
7595.                    }
7596.                    cast_expression();
7597.                }
7598.                else {
7599.                    break _loop397;
7600.                }
7601.                
7602.            } while (true);
7603.            }
7604.        }
7605.        
7606.        public final void cast_expression() throws RecognitionException, TokenStreamException {
7607.            
7608.            
7609.            boolean synPredMatched402 = false;
7610.            if (((LA(1)==LPAREN) && (_tokenSet_66.member(LA(2))))) {
7611.                int _m402 = mark();
7612.                synPredMatched402 = true;
7613.                inputState.guessing++;
7614.                try {
7615.                    {
7616.                    match(LPAREN);
7617.                    {
7618.                    switch ( LA(1)) {
7619.                    case LITERAL_const:
7620.                    case LITERAL_const_cast:
7621.                    case LITERAL_volatile:
7622.                    {
7623.                        type_qualifier();
7624.                        break;
7625.                    }
7626.                    case ID:
7627.                    case LITERAL__declspec:
7628.                    case LITERAL___declspec:
7629.                    case LITERAL_char:
7630.                    case LITERAL_wchar_t:
7631.                    case LITERAL_bool:
7632.                    case LITERAL_short:
7633.                    case LITERAL_int:
7634.                    case 44:
7635.                    case 45:
7636.                    case 46:
7637.                    case LITERAL_long:
7638.                    case LITERAL_signed:
7639.                    case LITERAL_unsigned:
7640.                    case LITERAL_float:
7641.                    case LITERAL_double:
7642.                    case LITERAL_void:
7643.                    case SCOPE:
7644.                    {
7645.                        break;
7646.                    }
7647.                    default:
7648.                    {
7649.                        throw new NoViableAltException(LT(1), getFilename());
7650.                    }
7651.                    }
7652.                    }
7653.                    simple_type_specifier();
7654.                    {
7655.                    switch ( LA(1)) {
7656.                    case ID:
7657.                    case LITERAL__stdcall:
7658.                    case LITERAL___stdcall:
7659.                    case STAR:
7660.                    case AMPERSAND:
7661.                    case SCOPE:
7662.                    case LITERAL__cdecl:
7663.                    case LITERAL___cdecl:
7664.                    case LITERAL__near:
7665.                    case LITERAL___near:
7666.                    case LITERAL__far:
7667.                    case LITERAL___far:
7668.                    case LITERAL___interrupt:
7669.                    case LITERAL_pascal:
7670.                    case LITERAL__pascal:
7671.                    case LITERAL___pascal:
7672.                    {
7673.                        ptr_operator();
7674.                        break;
7675.                    }
7676.                    case RPAREN:
7677.                    {
7678.                        break;
7679.                    }
7680.                    default:
7681.                    {
7682.                        throw new NoViableAltException(LT(1), getFilename());
7683.                    }
7684.                    }
7685.                    }
7686.                    match(RPAREN);
7687.                    }
7688.                }
7689.                catch (RecognitionException pe) {
7690.                    synPredMatched402 = false;
7691.                }
7692.                rewind(_m402);
7693.    inputState.guessing--;
7694.            }
7695.            if ( synPredMatched402 ) {
7696.                match(LPAREN);
7697.                {
7698.                switch ( LA(1)) {
7699.                case LITERAL_const:
7700.                case LITERAL_const_cast:
7701.                case LITERAL_volatile:
7702.                {
7703.                    type_qualifier();
7704.                    break;
7705.                }
7706.                case ID:
7707.                case LITERAL__declspec:
7708.                case LITERAL___declspec:
7709.                case LITERAL_char:
7710.                case LITERAL_wchar_t:
7711.                case LITERAL_bool:
7712.                case LITERAL_short:
7713.                case LITERAL_int:
7714.                case 44:
7715.                case 45:
7716.                case 46:
7717.                case LITERAL_long:
7718.                case LITERAL_signed:
7719.                case LITERAL_unsigned:
7720.                case LITERAL_float:
7721.                case LITERAL_double:
7722.                case LITERAL_void:
7723.                case SCOPE:
7724.                {
7725.                    break;
7726.                }
7727.                default:
7728.                {
7729.                    throw new NoViableAltException(LT(1), getFilename());
7730.                }
7731.                }
7732.                }
7733.                simple_type_specifier();
7734.                {
7735.                switch ( LA(1)) {
7736.                case ID:
7737.                case LITERAL__stdcall:
7738.                case LITERAL___stdcall:
7739.                case STAR:
7740.                case AMPERSAND:
7741.                case SCOPE:
7742.                case LITERAL__cdecl:
7743.                case LITERAL___cdecl:
7744.                case LITERAL__near:
7745.                case LITERAL___near:
7746.                case LITERAL__far:
7747.                case LITERAL___far:
7748.                case LITERAL___interrupt:
7749.                case LITERAL_pascal:
7750.                case LITERAL__pascal:
7751.                case LITERAL___pascal:
7752.                {
7753.                    ptr_operator();
7754.                    break;
7755.                }
7756.                case RPAREN:
7757.                {
7758.                    break;
7759.                }
7760.                default:
7761.                {
7762.                    throw new NoViableAltException(LT(1), getFilename());
7763.                }
7764.                }
7765.                }
7766.                match(RPAREN);
7767.                cast_expression();
7768.            }
7769.            else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7770.                unary_expression();
7771.            }
7772.            else {
7773.                throw new NoViableAltException(LT(1), getFilename());
7774.            }
7775.            
7776.        }
7777.        
7778.        public final void unary_expression() throws RecognitionException, TokenStreamException {
7779.            
7780.            
7781.            {
7782.            switch ( LA(1)) {
7783.            case PLUSPLUS:
7784.            {
7785.                match(PLUSPLUS);
7786.                unary_expression();
7787.                break;
7788.            }
7789.            case MINUSMINUS:
7790.            {
7791.                match(MINUSMINUS);
7792.                unary_expression();
7793.                break;
7794.            }
7795.            case LITERAL_sizeof:
7796.            {
7797.                match(LITERAL_sizeof);
7798.                {
7799.                if (((LA(1)==LPAREN) && (_tokenSet_11.member(LA(2))))&&((!(((LA(1)==LPAREN&&(LA(2)==ID))))||(isTy...
7800.                    match(LPAREN);
7801.                    type_name();
7802.                    match(RPAREN);
7803.                }
7804.                else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
7805.                    unary_expression();
7806.                }
7807.                else {
7808.                    throw new NoViableAltException(LT(1), getFilename());
7809.                }
7810.                
7811.                }
7812.                break;
7813.            }
7814.            default:
7815.                boolean synPredMatched408 = false;
7816.                if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) {
7817.                    int _m408 = mark();
7818.                    synPredMatched408 = true;
7819.                    inputState.guessing++;
7820.                    try {
7821.                        {
7822.                        postfix_expression();
7823.                        }
7824.                    }
7825.                    catch (RecognitionException pe) {
7826.                        synPredMatched408 = false;
7827.                    }
7828.                    rewind(_m408);
7829.    inputState.guessing--;
7830.                }
7831.                if ( synPredMatched408 ) {
7832.                    postfix_expression();
7833.                }
7834.                else if ((_tokenSet_69.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
7835.                    unary_operator();
7836.                    cast_expression();
7837.                }
7838.                else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) {
7839.                    {
7840.                    switch ( LA(1)) {
7841.                    case SCOPE:
7842.                    {
7843.                        match(SCOPE);
7844.                        break;
7845.                    }
7846.                    case LITERAL_new:
7847.                    case LITERAL_delete:
7848.                    {
7849.                        break;
7850.                    }
7851.                    default:
7852.                    {
7853.                        throw new NoViableAltException(LT(1), getFilename());
7854.                    }
7855.                    }
7856.                    }
7857.                    {
7858.                    switch ( LA(1)) {
7859.                    case LITERAL_new:
7860.                    {
7861.                        new_expression();
7862.                        break;
7863.                    }
7864.                    case LITERAL_delete:
7865.                    {
7866.                        delete_expression();
7867.                        break;
7868.                    }
7869.                    default:
7870.                    {
7871.                        throw new NoViableAltException(LT(1), getFilename());
7872.                    }
7873.                    }
7874.                    }
7875.                }
7876.            else {
7877.                throw new NoViableAltException(LT(1), getFilename());
7878.            }
7879.            }
7880.            }
7881.        }
7882.        
7883.        public final void postfix_expression() throws RecognitionException, TokenStreamException {
7884.            
7885.            
7886.            {
7887.            boolean synPredMatched415 = false;
7888.            if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7889.                int _m415 = mark();
7890.                synPredMatched415 = true;
7891.                inputState.guessing++;
7892.                try {
7893.                    {
7894.                    simple_type_specifier();
7895.                    match(LPAREN);
7896.                    match(RPAREN);
7897.                    match(LPAREN);
7898.                    }
7899.                }
7900.                catch (RecognitionException pe) {
7901.                    synPredMatched415 = false;
7902.                }
7903.                rewind(_m415);
7904.    inputState.guessing--;
7905.            }
7906.            if ( synPredMatched415 ) {
7907.                simple_type_specifier();
7908.                match(LPAREN);
7909.                match(RPAREN);
7910.                match(LPAREN);
7911.                {
7912.                switch ( LA(1)) {
7913.                case ID:
7914.                case StringLiteral:
7915.                case LITERAL__declspec:
7916.                case LITERAL___declspec:
7917.                case LPAREN:
7918.                case LITERAL_const_cast:
7919.                case LITERAL_char:
7920.                case LITERAL_wchar_t:
7921.                case LITERAL_bool:
7922.                case LITERAL_short:
7923.                case LITERAL_int:
7924.                case 44:
7925.                case 45:
7926.                case 46:
7927.                case LITERAL_long:
7928.                case LITERAL_signed:
7929.                case LITERAL_unsigned:
7930.                case LITERAL_float:
7931.                case LITERAL_double:
7932.                case LITERAL_void:
7933.                case OPERATOR:
7934.                case LITERAL_this:
7935.                case LITERAL_true:
7936.                case LITERAL_false:
7937.                case OCTALINT:
7938.                case STAR:
7939.                case AMPERSAND:
7940.                case TILDE:
7941.                case PLUS:
7942.                case MINUS:
7943.                case PLUSPLUS:
7944.                case MINUSMINUS:
7945.                case LITERAL_sizeof:
7946.                case SCOPE:
7947.                case LITERAL_dynamic_cast:
7948.                case LITERAL_static_cast:
7949.                case LITERAL_reinterpret_cast:
7950.                case NOT:
7951.                case LITERAL_new:
7952.                case LITERAL_delete:
7953.                case DECIMALINT:
7954.                case HEXADECIMALINT:
7955.                case CharLiteral:
7956.                case FLOATONE:
7957.                case FLOATTWO:
7958.                {
7959.                    expression_list();
7960.                    break;
7961.                }
7962.                case RPAREN:
7963.                {
7964.                    break;
7965.                }
7966.                default:
7967.                {
7968.                    throw new NoViableAltException(LT(1), getFilename());
7969.                }
7970.                }
7971.                }
7972.                match(RPAREN);
7973.            }
7974.            else {
7975.                boolean synPredMatched418 = false;
7976.                if ((((_tokenSet_55.member(LA(1))) && (_tokenSet_72.member(LA(2))))&&(!(LA(1)==LPAREN)))) {
7977.                    int _m418 = mark();
7978.                    synPredMatched418 = true;
7979.                    inputState.guessing++;
7980.                    try {
7981.                        {
7982.                        simple_type_specifier();
7983.                        match(LPAREN);
7984.                        }
7985.                    }
7986.                    catch (RecognitionException pe) {
7987.                        synPredMatched418 = false;
7988.                    }
7989.                    rewind(_m418);
7990.    inputState.guessing--;
7991.                }
7992.                if ( synPredMatched418 ) {
7993.                    simple_type_specifier();
7994.                    match(LPAREN);
7995.                    {
7996.                    switch ( LA(1)) {
7997.                    case ID:
7998.                    case StringLiteral:
7999.                    case LITERAL__declspec:
8000.                    case LITERAL___declspec:
8001.                    case LPAREN:
8002.                    case LITERAL_const_cast:
8003.                    case LITERAL_char:
8004.                    case LITERAL_wchar_t:
8005.                    case LITERAL_bool:
8006.                    case LITERAL_short:
8007.                    case LITERAL_int:
8008.                    case 44:
8009.                    case 45:
8010.                    case 46:
8011.                    case LITERAL_long:
8012.                    case LITERAL_signed:
8013.                    case LITERAL_unsigned:
8014.                    case LITERAL_float:
8015.                    case LITERAL_double:
8016.                    case LITERAL_void:
8017.                    case OPERATOR:
8018.                    case LITERAL_this:
8019.                    case LITERAL_true:
8020.                    case LITERAL_false:
8021.                    case OCTALINT:
8022.                    case STAR:
8023.                    case AMPERSAND:
8024.                    case TILDE:
8025.                    case PLUS:
8026.                    case MINUS:
8027.                    case PLUSPLUS:
8028.                    case MINUSMINUS:
8029.                    case LITERAL_sizeof:
8030.                    case SCOPE:
8031.                    case LITERAL_dynamic_cast:
8032.                    case LITERAL_static_cast:
8033.                    case LITERAL_reinterpret_cast:
8034.                    case NOT:
8035.                    case LITERAL_new:
8036.                    case LITERAL_delete:
8037.                    case DECIMALINT:
8038.                    case HEXADECIMALINT:
8039.                    case CharLiteral:
8040.                    case FLOATONE:
8041.                    case FLOATTWO:
8042.                    {
8043.                        expression_list();
8044.                        break;
8045.                    }
8046.                    case RPAREN:
8047.                    {
8048.                        break;
8049.                    }
8050.                    default:
8051.                    {
8052.                        throw new NoViableAltException(LT(1), getFilename());
8053.                    }
8054.                    }
8055.                    }
8056.                    match(RPAREN);
8057.                }
8058.                else if ((_tokenSet_73.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
8059.                    primary_expression();
8060.                    {
8061.                    _loop422:
8062.                    do {
8063.                        switch ( LA(1)) {
8064.                        case LSQUARE:
8065.                        {
8066.                            match(LSQUARE);
8067.                            expression();
8068.                            match(RSQUARE);
8069.                            break;
8070.                        }
8071.                        case LPAREN:
8072.                        {
8073.                            match(LPAREN);
8074.                            {
8075.                            switch ( LA(1)) {
8076.                            case ID:
8077.                            case StringLiteral:
8078.                            case LITERAL__declspec:
8079.                            case LITERAL___declspec:
8080.                            case LPAREN:
8081.                            case LITERAL_const_cast:
8082.                            case LITERAL_char:
8083.                            case LITERAL_wchar_t:
8084.                            case LITERAL_bool:
8085.                            case LITERAL_short:
8086.                            case LITERAL_int:
8087.                            case 44:
8088.                            case 45:
8089.                            case 46:
8090.                            case LITERAL_long:
8091.                            case LITERAL_signed:
8092.                            case LITERAL_unsigned:
8093.                            case LITERAL_float:
8094.                            case LITERAL_double:
8095.                            case LITERAL_void:
8096.                            case OPERATOR:
8097.                            case LITERAL_this:
8098.                            case LITERAL_true:
8099.                            case LITERAL_false:
8100.                            case OCTALINT:
8101.                            case STAR:
8102.                            case AMPERSAND:
8103.                            case TILDE:
8104.                            case PLUS:
8105.                            case MINUS:
8106.                            case PLUSPLUS:
8107.                            case MINUSMINUS:
8108.                            case LITERAL_sizeof:
8109.                            case SCOPE:
8110.                            case LITERAL_dynamic_cast:
8111.                            case LITERAL_static_cast:
8112.                            case LITERAL_reinterpret_cast:
8113.                            case NOT:
8114.                            case LITERAL_new:
8115.                            case LITERAL_delete:
8116.                            case DECIMALINT:
8117.                            case HEXADECIMALINT:
8118.                            case CharLiteral:
8119.                            case FLOATONE:
8120.                            case FLOATTWO:
8121.                            {
8122.                                expression_list();
8123.                                break;
8124.                            }
8125.                            case RPAREN:
8126.                            {
8127.                                break;
8128.                            }
8129.                            default:
8130.                            {
8131.                                throw new NoViableAltException(LT(1), getFilename());
8132.                            }
8133.                            }
8134.                            }
8135.                            match(RPAREN);
8136.                            break;
8137.                        }
8138.                        case DOT:
8139.                        {
8140.                            match(DOT);
8141.                            id_expression();
8142.                            break;
8143.                        }
8144.                        case POINTERTO:
8145.                        {
8146.                            match(POINTERTO);
8147.                            id_expression();
8148.                            break;
8149.                        }
8150.                        case PLUSPLUS:
8151.                        {
8152.                            match(PLUSPLUS);
8153.                            break;
8154.                        }
8155.                        case MINUSMINUS:
8156.                        {
8157.                            match(MINUSMINUS);
8158.                            break;
8159.                        }
8160.                        default:
8161.                        {
8162.                            break _loop422;
8163.                        }
8164.                        }
8165.                    } while (true);
8166.                    }
8167.                }
8168.                else if ((_tokenSet_74.member(LA(1)))) {
8169.                    {
8170.                    switch ( LA(1)) {
8171.                    case LITERAL_dynamic_cast:
8172.                    {
8173.                        match(LITERAL_dynamic_cast);
8174.                        break;
8175.                    }
8176.                    case LITERAL_static_cast:
8177.                    {
8178.                        match(LITERAL_static_cast);
8179.                        break;
8180.                    }
8181.                    case LITERAL_reinterpret_cast:
8182.                    {
8183.                        match(LITERAL_reinterpret_cast);
8184.                        break;
8185.                    }
8186.                    case LITERAL_const_cast:
8187.                    {
8188.                        match(LITERAL_const_cast);
8189.                        break;
8190.                    }
8191.                    default:
8192.                    {
8193.                        throw new NoViableAltException(LT(1), getFilename());
8194.                    }
8195.                    }
8196.                    }
8197.                    match(LESSTHAN);
8198.                    type_specifier();
8199.                    {
8200.                    switch ( LA(1)) {
8201.                    case ID:
8202.                    case LITERAL__stdcall:
8203.                    case LITERAL___stdcall:
8204.                    case STAR:
8205.                    case AMPERSAND:
8206.                    case SCOPE:
8207.                    case LITERAL__cdecl:
8208.                    case LITERAL___cdecl:
8209.                    case LITERAL__near:
8210.                    case LITERAL___near:
8211.                    case LITERAL__far:
8212.                    case LITERAL___far:
8213.                    case LITERAL___interrupt:
8214.                    case LITERAL_pascal:
8215.                    case LITERAL__pascal:
8216.                    case LITERAL___pascal:
8217.                    {
8218.                        ptr_operator();
8219.                        break;
8220.                    }
8221.                    case GREATERTHAN:
8222.                    {
8223.                        break;
8224.                    }
8225.                    default:
8226.                    {
8227.                        throw new NoViableAltException(LT(1), getFilename());
8228.                    }
8229.                    }
8230.                    }
8231.                    match(GREATERTHAN);
8232.                    match(LPAREN);
8233.                    expression();
8234.                    match(RPAREN);
8235.                }
8236.                else {
8237.                    throw new NoViableAltException(LT(1), getFilename());
8238.                }
8239.                }
8240.                }
8241.            }
8242.            
8243.        public final void unary_operator() throws RecognitionException, TokenStreamException {
8244.            
8245.            
8246.            switch ( LA(1)) {
8247.            case AMPERSAND:
8248.            {
8249.                match(AMPERSAND);
8250.                break;
8251.            }
8252.            case STAR:
8253.            {
8254.                match(STAR);
8255.                break;
8256.            }
8257.            case PLUS:
8258.            {
8259.                match(PLUS);
8260.                break;
8261.            }
8262.            case MINUS:
8263.            {
8264.                match(MINUS);
8265.                break;
8266.            }
8267.            case TILDE:
8268.            {
8269.                match(TILDE);
8270.                break;
8271.            }
8272.            case NOT:
8273.            {
8274.                match(NOT);
8275.                break;
8276.            }
8277.            default:
8278.            {
8279.                throw new NoViableAltException(LT(1), getFilename());
8280.            }
8281.            }
8282.        }
8283.        
8284.        public final void new_expression() throws RecognitionException, TokenStreamException {
8285.            
8286.            
8287.            {
8288.            match(LITERAL_new);
8289.            {
8290.            boolean synPredMatched434 = false;
8291.            if (((LA(1)==LPAREN) && (_tokenSet_42.member(LA(2))))) {
8292.                int _m434 = mark();
8293.                synPredMatched434 = true;
8294.                inputState.guessing++;
8295.                try {
8296.                    {
8297.                    match(LPAREN);
8298.                    expression_list();
8299.                    match(RPAREN);
8300.                    }
8301.                }
8302.                catch (RecognitionException pe) {
8303.                    synPredMatched434 = false;
8304.                }
8305.                rewind(_m434);
8306.    inputState.guessing--;
8307.            }
8308.            if ( synPredMatched434 ) {
8309.                match(LPAREN);
8310.                expression_list();
8311.                match(RPAREN);
8312.            }
8313.            else if ((_tokenSet_75.member(LA(1))) && (_tokenSet_76.member(LA(2)))) {
8314.            }
8315.            else {
8316.                throw new NoViableAltException(LT(1), getFilename());
8317.            }
8318.            
8319.            }
8320.            {
8321.            switch ( LA(1)) {
8322.            case LITERAL_typedef:
8323.            case LITERAL_enum:
8324.            case ID:
8325.            case LITERAL_inline:
8326.            case LITERAL_extern:
8327.            case LITERAL__inline:
8328.            case LITERAL___inline:
8329.            case LITERAL_virtual:
8330.            case LITERAL_explicit:
8331.            case LITERAL_friend:
8332.            case LITERAL__stdcall:
8333.            case LITERAL___stdcall:
8334.            case LITERAL__declspec:
8335.            case LITERAL___declspec:
8336.            case LITERAL_typename:
8337.            case LITERAL_auto:
8338.            case LITERAL_register:
8339.            case LITERAL_static:
8340.            case LITERAL_mutable:
8341.            case LITERAL_const:
8342.            case LITERAL_const_cast:
8343.            case LITERAL_volatile:
8344.            case LITERAL_char:
8345.            case LITERAL_wchar_t:
8346.            case LITERAL_bool:
8347.            case LITERAL_short:
8348.            case LITERAL_int:
8349.            case 44:
8350.            case 45:
8351.            case 46:
8352.            case LITERAL_long:
8353.            case LITERAL_signed:
8354.            case LITERAL_unsigned:
8355.            case LITERAL_float:
8356.            case LITERAL_double:
8357.            case LITERAL_void:
8358.            case LITERAL_class:
8359.            case LITERAL_struct:
8360.            case LITERAL_union:
8361.            case SCOPE:
8362.            {
8363.                new_type_id();
8364.                break;
8365.            }
8366.            case LPAREN:
8367.            {
8368.                match(LPAREN);
8369.                type_name();
8370.                match(RPAREN);
8371.                break;
8372.            }
8373.            default:
8374.            {
8375.                throw new NoViableAltException(LT(1), getFilename());
8376.            }
8377.            }
8378.            }
8379.            {
8380.            switch ( LA(1)) {
8381.            case LPAREN:
8382.            {
8383.                new_initializer();
8384.                break;
8385.            }
8386.            case LESSTHAN:
8387.            case GREATERTHAN:
8388.            case SEMICOLON:
8389.            case RCURLY:
8390.            case ASSIGNEQUAL:
8391.            case COLON:
8392.            case COMMA:
8393.            case RPAREN:
8394.            case STAR:
8395.            case AMPERSAND:
8396.            case RSQUARE:
8397.            case ELLIPSIS:
8398.            case TIMESEQUAL:
8399.            case DIVIDEEQUAL:
8400.            case MINUSEQUAL:
8401.            case PLUSEQUAL:
8402.            case MODEQUAL:
8403.            case SHIFTLEFTEQUAL:
8404.            case SHIFTRIGHTEQUAL:
8405.            case BITWISEANDEQUAL:
8406.            case BITWISEXOREQUAL:
8407.            case BITWISEOREQUAL:
8408.            case QUESTIONMARK:
8409.            case OR:
8410.            case AND:
8411.            case BITWISEOR:
8412.            case BITWISEXOR:
8413.            case NOTEQUAL:
8414.            case EQUAL:
8415.            case LESSTHANOREQUALTO:
8416.            case GREATERTHANOREQUALTO:
8417.            case SHIFTLEFT:
8418.            case SHIFTRIGHT:
8419.            case PLUS:
8420.            case MINUS:
8421.            case DIVIDE:
8422.            case MOD:
8423.            case DOTMBR:
8424.            case POINTERTOMBR:
8425.            {
8426.                break;
8427.            }
8428.            default:
8429.            {
8430.                throw new NoViableAltException(LT(1), getFilename());
8431.            }
8432.            }
8433.            }
8434.            }
8435.        }
8436.        
8437.        public final void delete_expression() throws RecognitionException, TokenStreamException {
8438.            
8439.            
8440.            match(LITERAL_delete);
8441.            {
8442.            switch ( LA(1)) {
8443.            case LSQUARE:
8444.            {
8445.                match(LSQUARE);
8446.                match(RSQUARE);
8447.                break;
8448.            }
8449.            case ID:
8450.            case StringLiteral:
8451.            case LITERAL__declspec:
8452.            case LITERAL___declspec:
8453.            case LPAREN:
8454.            case LITERAL_const_cast:
8455.            case LITERAL_char:
8456.            case LITERAL_wchar_t:
8457.            case LITERAL_bool:
8458.            case LITERAL_short:
8459.            case LITERAL_int:
8460.            case 44:
8461.            case 45:
8462.            case 46:
8463.            case LITERAL_long:
8464.            case LITERAL_signed:
8465.            case LITERAL_unsigned:
8466.            case LITERAL_float:
8467.            case LITERAL_double:
8468.            case LITERAL_void:
8469.            case OPERATOR:
8470.            case LITERAL_this:
8471.            case LITERAL_true:
8472.            case LITERAL_false:
8473.            case OCTALINT:
8474.            case STAR:
8475.            case AMPERSAND:
8476.            case TILDE:
8477.            case PLUS:
8478.            case MINUS:
8479.            case PLUSPLUS:
8480.            case MINUSMINUS:
8481.            case LITERAL_sizeof:
8482.            case SCOPE:
8483.            case LITERAL_dynamic_cast:
8484.            case LITERAL_static_cast:
8485.            case LITERAL_reinterpret_cast:
8486.            case NOT:
8487.            case LITERAL_new:
8488.            case LITERAL_delete:
8489.            case DECIMALINT:
8490.            case HEXADECIMALINT:
8491.            case CharLiteral:
8492.            case FLOATONE:
8493.            case FLOATTWO:
8494.            {
8495.                break;
8496.            }
8497.            default:
8498.            {
8499.                throw new NoViableAltException(LT(1), getFilename());
8500.            }
8501.            }
8502.            }
8503.            cast_expression();
8504.        }
8505.        
8506.        public final void primary_expression() throws RecognitionException, TokenStreamException {
8507.            
8508.            
8509.            switch ( LA(1)) {
8510.            case ID:
8511.            case OPERATOR:
8512.            case TILDE:
8513.            case SCOPE:
8514.            {
8515.                id_expression();
8516.                break;
8517.            }
8518.            case StringLiteral:
8519.            case LITERAL_true:
8520.            case LITERAL_false:
8521.            case OCTALINT:
8522.            case DECIMALINT:
8523.            case HEXADECIMALINT:
8524.            case CharLiteral:
8525.            case FLOATONE:
8526.            case FLOATTWO:
8527.            {
8528.                constant();
8529.                break;
8530.            }
8531.            case LITERAL_this:
8532.            {
8533.                match(LITERAL_this);
8534.                break;
8535.            }
8536.            case LPAREN:
8537.            {
8538.                match(LPAREN);
8539.                expression();
8540.                match(RPAREN);
8541.                break;
8542.            }
8543.            default:
8544.            {
8545.                throw new NoViableAltException(LT(1), getFilename());
8546.            }
8547.            }
8548.        }
8549.        
8550.        public final void id_expression() throws RecognitionException, TokenStreamException {
8551.            
8552.            String s="";
8553.            
8554.            s=scope_override();
8555.            {
8556.            switch ( LA(1)) {
8557.            case ID:
8558.            {
8559.                match(ID);
8560.                break;
8561.            }
8562.            case OPERATOR:
8563.            {
8564.                match(OPERATOR);
8565.                optor();
8566.                break;
8567.            }
8568.            case TILDE:
8569.            {
8570.                match(TILDE);
8571.                {
8572.                switch ( LA(1)) {
8573.                case STAR:
8574.                {
8575.                    match(STAR);
8576.                    break;
8577.                }
8578.                case ID:
8579.                {
8580.                    break;
8581.                }
8582.                default:
8583.                {
8584.                    throw new NoViableAltException(LT(1), getFilename());
8585.                }
8586.                }
8587.                }
8588.                match(ID);
8589.                break;
8590.            }
8591.            default:
8592.            {
8593.                throw new NoViableAltException(LT(1), getFilename());
8594.            }
8595.            }
8596.            }
8597.        }
8598.        
8599.        public final void constant() throws RecognitionException, TokenStreamException {
8600.            
8601.            
8602.            switch ( LA(1)) {
8603.            case OCTALINT:
8604.            {
8605.                match(OCTALINT);
8606.                break;
8607.            }
8608.            case DECIMALINT:
8609.            {
8610.                match(DECIMALINT);
8611.                break;
8612.            }
8613.            case HEXADECIMALINT:
8614.            {
8615.                match(HEXADECIMALINT);
8616.                break;
8617.            }
8618.            case CharLiteral:
8619.            {
8620.                match(CharLiteral);
8621.                break;
8622.            }
8623.            case StringLiteral:
8624.            {
8625.                {
8626.                int _cnt468=0;
8627.                _loop468:
8628.                do {
8629.                    if ((LA(1)==StringLiteral)) {
8630.                        match(StringLiteral);
8631.                    }
8632.                    else {
8633.                        if ( _cnt468>=1 ) { break _loop468; } else {throw new NoViableAltException(LT(1), getFilename()...
8634.                    }
8635.                    
8636.                    _cnt468++;
8637.                } while (true);
8638.                }
8639.                break;
8640.            }
8641.            case FLOATONE:
8642.            {
8643.                match(FLOATONE);
8644.                break;
8645.            }
8646.            case FLOATTWO:
8647.            {
8648.                match(FLOATTWO);
8649.                break;
8650.            }
8651.            case LITERAL_true:
8652.            {
8653.                match(LITERAL_true);
8654.                break;
8655.            }
8656.            case LITERAL_false:
8657.            {
8658.                match(LITERAL_false);
8659.                break;
8660.            }
8661.            default:
8662.            {
8663.                throw new NoViableAltException(LT(1), getFilename());
8664.            }
8665.            }
8666.        }
8667.        
8668.        public final void new_type_id() throws RecognitionException, TokenStreamException {
8669.            
8670.            
8671.            declaration_specifiers();
8672.            {
8673.            if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8674.                new_declarator();
8675.            }
8676.            else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8677.            }
8678.            else {
8679.                throw new NoViableAltException(LT(1), getFilename());
8680.            }
8681.            
8682.            }
8683.        }
8684.        
8685.        public final void new_initializer() throws RecognitionException, TokenStreamException {
8686.            
8687.            
8688.            match(LPAREN);
8689.            {
8690.            switch ( LA(1)) {
8691.            case ID:
8692.            case StringLiteral:
8693.            case LITERAL__declspec:
8694.            case LITERAL___declspec:
8695.            case LPAREN:
8696.            case LITERAL_const_cast:
8697.            case LITERAL_char:
8698.            case LITERAL_wchar_t:
8699.            case LITERAL_bool:
8700.            case LITERAL_short:
8701.            case LITERAL_int:
8702.            case 44:
8703.            case 45:
8704.            case 46:
8705.            case LITERAL_long:
8706.            case LITERAL_signed:
8707.            case LITERAL_unsigned:
8708.            case LITERAL_float:
8709.            case LITERAL_double:
8710.            case LITERAL_void:
8711.            case OPERATOR:
8712.            case LITERAL_this:
8713.            case LITERAL_true:
8714.            case LITERAL_false:
8715.            case OCTALINT:
8716.            case STAR:
8717.            case AMPERSAND:
8718.            case TILDE:
8719.            case PLUS:
8720.            case MINUS:
8721.            case PLUSPLUS:
8722.            case MINUSMINUS:
8723.            case LITERAL_sizeof:
8724.            case SCOPE:
8725.            case LITERAL_dynamic_cast:
8726.            case LITERAL_static_cast:
8727.            case LITERAL_reinterpret_cast:
8728.            case NOT:
8729.            case LITERAL_new:
8730.            case LITERAL_delete:
8731.            case DECIMALINT:
8732.            case HEXADECIMALINT:
8733.            case CharLiteral:
8734.            case FLOATONE:
8735.            case FLOATTWO:
8736.            {
8737.                expression_list();
8738.                break;
8739.            }
8740.            case RPAREN:
8741.            {
8742.                break;
8743.            }
8744.            default:
8745.            {
8746.                throw new NoViableAltException(LT(1), getFilename());
8747.            }
8748.            }
8749.            }
8750.            match(RPAREN);
8751.        }
8752.        
8753.        public final void new_declarator() throws RecognitionException, TokenStreamException {
8754.            
8755.            
8756.            switch ( LA(1)) {
8757.            case ID:
8758.            case LITERAL__stdcall:
8759.            case LITERAL___stdcall:
8760.            case STAR:
8761.            case AMPERSAND:
8762.            case SCOPE:
8763.            case LITERAL__cdecl:
8764.            case LITERAL___cdecl:
8765.            case LITERAL__near:
8766.            case LITERAL___near:
8767.            case LITERAL__far:
8768.            case LITERAL___far:
8769.            case LITERAL___interrupt:
8770.            case LITERAL_pascal:
8771.            case LITERAL__pascal:
8772.            case LITERAL___pascal:
8773.            {
8774.                ptr_operator();
8775.                {
8776.                if ((_tokenSet_77.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
8777.                    new_declarator();
8778.                }
8779.                else if ((_tokenSet_79.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
8780.                }
8781.                else {
8782.                    throw new NoViableAltException(LT(1), getFilename());
8783.                }
8784.                
8785.                }
8786.                break;
8787.            }
8788.            case LSQUARE:
8789.            {
8790.                direct_new_declarator();
8791.                break;
8792.            }
8793.            default:
8794.            {
8795.                throw new NoViableAltException(LT(1), getFilename());
8796.            }
8797.            }
8798.        }
8799.        
8800.        public final void direct_new_declarator() throws RecognitionException, TokenStreamException {
8801.            
8802.            
8803.            {
8804.            int _cnt460=0;
8805.            _loop460:
8806.            do {
8807.                if ((LA(1)==LSQUARE)) {
8808.                    match(LSQUARE);
8809.                    expression();
8810.                    match(RSQUARE);
8811.                }
8812.                else {
8813.                    if ( _cnt460>=1 ) { break _loop460; } else {throw new NoViableAltException(LT(1), getFilename())...
8814.                }
8815.                
8816.                _cnt460++;
8817.            } while (true);
8818.            }
8819.        }
8820.        
8821.        public final void ptr_to_member() throws RecognitionException, TokenStreamException {
8822.            
8823.            String s="";
8824.            
8825.            s=scope_override();
8826.            match(STAR);
8827.            if ( inputState.guessing==0 ) {
8828.                
8829.                        if (s.length() != 0) m.ptrToMember(s, "*");
8830.                        else m.ptrOperator("*");
8831.                    
8832.            }
8833.            cv_qualifier_seq();
8834.        }
8835.        
8836.        public final void optor_simple_tokclass() throws RecognitionException, TokenStreamException {
8837.            
8838.            
8839.            {
8840.            switch ( LA(1)) {
8841.            case PLUS:
8842.            {
8843.                match(PLUS);
8844.                break;
8845.            }
8846.            case MINUS:
8847.            {
8848.                match(MINUS);
8849.                break;
8850.            }
8851.            case STAR:
8852.            {
8853.                match(STAR);
8854.                break;
8855.            }
8856.            case DIVIDE:
8857.            {
8858.                match(DIVIDE);
8859.                break;
8860.            }
8861.            case MOD:
8862.            {
8863.                match(MOD);
8864.                break;
8865.            }
8866.            case BITWISEXOR:
8867.            {
8868.                match(BITWISEXOR);
8869.                break;
8870.            }
8871.            case AMPERSAND:
8872.            {
8873.                match(AMPERSAND);
8874.                break;
8875.            }
8876.            case BITWISEOR:
8877.            {
8878.                match(BITWISEOR);
8879.                break;
8880.            }
8881.            case TILDE:
8882.            {
8883.                match(TILDE);
8884.                break;
8885.            }
8886.            case NOT:
8887.            {
8888.                match(NOT);
8889.                break;
8890.            }
8891.            case SHIFTLEFT:
8892.            {
8893.                match(SHIFTLEFT);
8894.                break;
8895.            }
8896.            case SHIFTRIGHT:
8897.            {
8898.                match(SHIFTRIGHT);
8899.                break;
8900.            }
8901.            case ASSIGNEQUAL:
8902.            {
8903.                match(ASSIGNEQUAL);
8904.                break;
8905.            }
8906.            case TIMESEQUAL:
8907.            {
8908.                match(TIMESEQUAL);
8909.                break;
8910.            }
8911.            case DIVIDEEQUAL:
8912.            {
8913.                match(DIVIDEEQUAL);
8914.                break;
8915.            }
8916.            case MODEQUAL:
8917.            {
8918.                match(MODEQUAL);
8919.                break;
8920.            }
8921.            case PLUSEQUAL:
8922.            {
8923.                match(PLUSEQUAL);
8924.                break;
8925.            }
8926.            case MINUSEQUAL:
8927.            {
8928.                match(MINUSEQUAL);
8929.                break;
8930.            }
8931.            case SHIFTLEFTEQUAL:
8932.            {
8933.                match(SHIFTLEFTEQUAL);
8934.                break;
8935.            }
8936.            case SHIFTRIGHTEQUAL:
8937.            {
8938.                match(SHIFTRIGHTEQUAL);
8939.                break;
8940.            }
8941.            case BITWISEANDEQUAL:
8942.            {
8943.                match(BITWISEANDEQUAL);
8944.                break;
8945.            }
8946.            case BITWISEXOREQUAL:
8947.            {
8948.                match(BITWISEXOREQUAL);
8949.                break;
8950.            }
8951.            case BITWISEOREQUAL:
8952.            {
8953.                match(BITWISEOREQUAL);
8954.                break;
8955.            }
8956.            case EQUAL:
8957.            {
8958.                match(EQUAL);
8959.                break;
8960.            }
8961.            case NOTEQUAL:
8962.            {
8963.                match(NOTEQUAL);
8964.                break;
8965.            }
8966.            case LESSTHAN:
8967.            {
8968.                match(LESSTHAN);
8969.                break;
8970.            }
8971.            case GREATERTHAN:
8972.            {
8973.                match(GREATERTHAN);
8974.                break;
8975.            }
8976.            case LESSTHANOREQUALTO:
8977.            {
8978.                match(LESSTHANOREQUALTO);
8979.                break;
8980.            }
8981.            case GREATERTHANOREQUALTO:
8982.            {
8983.                match(GREATERTHANOREQUALTO);
8984.                break;
8985.            }
8986.            case OR:
8987.            {
8988.                match(OR);
8989.                break;
8990.            }
8991.            case AND:
8992.            {
8993.                match(AND);
8994.                break;
8995.            }
8996.            case PLUSPLUS:
8997.            {
8998.                match(PLUSPLUS);
8999.                break;
9000.            }
9001.            case MINUSMINUS:
9002.            {
9003.                match(MINUSMINUS);
9004.                break;
9005.            }
9006.            case COMMA:
9007.            {
9008.                match(COMMA);
9009.                break;
9010.            }
9011.            case POINTERTO:
9012.            {
9013.                match(POINTERTO);
9014.                break;
9015.            }
9016.            case POINTERTOMBR:
9017.            {
9018.                match(POINTERTOMBR);
9019.                break;
9020.            }
9021.            default:
9022.            {
9023.                throw new NoViableAltException(LT(1), getFilename());
9024.            }
9025.            }
9026.            }
9027.        }
9028.        
9029.        
9030.        public static final String[] _tokenNames = {
9031.            "<0>",
9032.            "EOF",
9033.            "<2>",
9034.            "NULL_TREE_LOOKAHEAD",
9035.            "\"template\"",
9036.            "LESSTHAN",
9037.            "GREATERTHAN",
9038.            "\"typedef\"",
9039.            "\"enum\"",
9040.            "ID",
9041.            "LCURLY",
9042.            "SEMICOLON",
9043.            "\"inline\"",
9044.            "\"namespace\"",
9045.            "RCURLY",
9046.            "ASSIGNEQUAL",
9047.            "COLON",
9048.            "\"extern\"",
9049.            "StringLiteral",
9050.            "COMMA",
9051.            "\"_inline\"",
9052.            "\"__inline\"",
9053.            "\"virtual\"",
9054.            "\"explicit\"",
9055.            "\"friend\"",
9056.            "\"_stdcall\"",
9057.            "\"__stdcall\"",
9058.            "\"_declspec\"",
9059.            "\"__declspec\"",
9060.            "LPAREN",
9061.            "RPAREN",
9062.            "\"typename\"",
9063.            "\"auto\"",
9064.            "\"register\"",
9065.            "\"static\"",
9066.            "\"mutable\"",
9067.            "\"const\"",
9068.            "\"const_cast\"",
9069.            "\"volatile\"",
9070.            "\"char\"",
9071.            "\"wchar_t\"",
9072.            "\"bool\"",
9073.            "\"short\"",
9074.            "\"int\"",
9075.            "\"_int64\"",
9076.            "\"__int64\"",
9077.            "\"__w64\"",
9078.            "\"long\"",
9079.            "\"signed\"",
9080.            "\"unsigned\"",
9081.            "\"float\"",
9082.            "\"double\"",
9083.            "\"void\"",
9084.            "\"class\"",
9085.            "\"struct\"",
9086.            "\"union\"",
9087.            "\"operator\"",
9088.            "\"this\"",
9089.            "\"true\"",
9090.            "\"false\"",
9091.            "\"public\"",
9092.            "\"protected\"",
9093.            "\"private\"",
9094.            "OCTALINT",
9095.            "STAR",
9096.            "AMPERSAND",
9097.            "LSQUARE",
9098.            "RSQUARE",
9099.            "TILDE",
9100.            "ELLIPSIS",
9101.            "\"throw\"",
9102.            "\"case\"",
9103.            "\"default\"",
9104.            "\"if\"",
9105.            "\"else\"",
9106.            "\"switch\"",
9107.            "\"while\"",
9108.            "\"do\"",
9109.            "\"for\"",
9110.            "\"goto\"",
9111.            "\"continue\"",
9112.            "\"break\"",
9113.            "\"return\"",
9114.            "\"try\"",
9115.            "\"catch\"",
9116.            "\"using\"",
9117.            "\"_asm\"",
9118.            "\"__asm\"",
9119.            "TIMESEQUAL",
9120.            "DIVIDEEQUAL",
9121.            "MINUSEQUAL",
9122.            "PLUSEQUAL",
9123.            "MODEQUAL",
9124.            "SHIFTLEFTEQUAL",
9125.            "SHIFTRIGHTEQUAL",
9126.            "BITWISEANDEQUAL",
9127.            "BITWISEXOREQUAL",
9128.            "BITWISEOREQUAL",
9129.            "QUESTIONMARK",
9130.            "OR",
9131.            "AND",
9132.            "BITWISEOR",
9133.            "BITWISEXOR",
9134.            "NOTEQUAL",
9135.            "EQUAL",
9136.            "LESSTHANOREQUALTO",
9137.            "GREATERTHANOREQUALTO",
9138.            "SHIFTLEFT",
9139.            "SHIFTRIGHT",
9140.            "PLUS",
9141.            "MINUS",
9142.            "DIVIDE",
9143.            "MOD",
9144.            "DOTMBR",
9145.            "POINTERTOMBR",
9146.            "PLUSPLUS",
9147.            "MINUSMINUS",
9148.            "\"sizeof\"",
9149.            "SCOPE",
9150.            "DOT",
9151.            "POINTERTO",
9152.            "\"dynamic_cast\"",
9153.            "\"static_cast\"",
9154.            "\"reinterpret_cast\"",
9155.            "NOT",
9156.            "\"new\"",
9157.            "\"_cdecl\"",
9158.            "\"__cdecl\"",
9159.            "\"_near\"",
9160.            "\"__near\"",
9161.            "\"_far\"",
9162.            "\"__far\"",
9163.            "\"__interrupt\"",
9164.            "\"pascal\"",
9165.            "\"_pascal\"",
9166.            "\"__pascal\"",
9167.            "\"delete\"",
9168.            "DECIMALINT",
9169.            "HEXADECIMALINT",
9170.            "CharLiteral",
9171.            "FLOATONE",
9172.            "FLOATTWO",
9173.            "Whitespace",
9174.            "Comment",
9175.            "CPPComment",
9176.            "DIRECTIVE",
9177.            "LineDirective",
9178.            "EndOfLine",
9179.            "Escape",
9180.            "Digit",
9181.            "Decimal",
9182.            "LongSuffix",
9183.            "UnsignedSuffix",
9184.            "FloatSuffix",
9185.            "Exponent",
9186.            "Vocabulary",
9187.            "Number"
9188.        };
9189.        
9190.        private static final long[] mk_tokenSet_0() {
9191.            long[] data = { 1152921503532202896L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9192.            return data;
9193.        }
9194.        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
9195.        private static final long[] mk_tokenSet_1() {
9196.            long[] data = { 72057592426402688L, 18014398511579136L, 0L, 0L};
9197.            return data;
9198.        }
9199.        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
9200.        private static final long[] mk_tokenSet_2() {
9201.            long[] data = { 1152921501385506720L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9202.            return data;
9203.        }
9204.        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
9205.        private static final long[] mk_tokenSet_3() {
9206.            long[] data = { 7344656L, 18014398509482000L, 0L, 0L};
9207.            return data;
9208.        }
9209.        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
9210.        private static final long[] mk_tokenSet_4() {
9211.            long[] data = { 7344672L, 18014398509482000L, 0L, 0L};
9212.            return data;
9213.        }
9214.        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
9215.        private static final long[] mk_tokenSet_5() {
9216.            long[] data = { 11538944L, 18014398509481984L, 0L, 0L};
9217.            return data;
9218.        }
9219.        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
9220.        private static final long[] mk_tokenSet_6() {
9221.            long[] data = { 548409888L, 18014398509481984L, 0L, 0L};
9222.            return data;
9223.        }
9224.        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
9225.        private static final long[] mk_tokenSet_7() {
9226.            long[] data = { 72057594037932544L, 18014398509481984L, 0L, 0L};
9227.            return data;
9228.        }
9229.        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
9230.        private static final long[] mk_tokenSet_8() {
9231.            long[] data = { 144115186464330656L, 18014398509481984L, 0L, 0L};
9232.            return data;
9233.        }
9234.        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
9235.        private static final long[] mk_tokenSet_9() {
9236.            long[] data = { 1152921503532192640L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9237.            return data;
9238.        }
9239.        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
9240.        private static final long[] mk_tokenSet_10() {
9241.            long[] data = { 1152921501385267168L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9242.            return data;
9243.        }
9244.        public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
9245.        private static final long[] mk_tokenSet_11() {
9246.            long[] data = { 72057592426402688L, 18014398509481984L, 0L, 0L};
9247.            return data;
9248.        }
9249.        public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
9250.        private static final long[] mk_tokenSet_12() {
9251.            long[] data = { 1152921501385236384L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9252.            return data;
9253.        }
9254.        public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
9255.        private static final long[] mk_tokenSet_13() {
9256.            long[] data = { 100663808L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9257.            return data;
9258.        }
9259.        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
9260.        private static final long[] mk_tokenSet_14() {
9261.            long[] data = { 1080864392242790944L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9262.            return data;
9263.        }
9264.        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
9265.        private static final long[] mk_tokenSet_15() {
9266.            long[] data = { 1080863911105790464L, 18014398509481984L, 0L, 0L};
9267.            return data;
9268.        }
9269.        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
9270.        private static final long[] mk_tokenSet_16() {
9271.            long[] data = { 1080863911106347616L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9272.            return data;
9273.        }
9274.        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
9275.        private static final long[] mk_tokenSet_17() {
9276.            long[] data = { 1152921501384710048L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9277.            return data;
9278.        }
9279.        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
9280.        private static final long[] mk_tokenSet_18() {
9281.            long[] data = { 72057592426403712L, 18014398511579136L, 0L, 0L};
9282.            return data;
9283.        }
9284.        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
9285.        private static final long[] mk_tokenSet_19() {
9286.            long[] data = { -8070450533321769056L, -110232637738583085L, 16383L, 0L, 0L, 0L};
9287.            return data;
9288.        }
9289.        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
9290.        private static final long[] mk_tokenSet_20() {
9291.            long[] data = { -8070450533322301568L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9292.            return data;
9293.        }
9294.        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
9295.        private static final long[] mk_tokenSet_21() {
9296.            long[] data = { 1080863911206453760L, -4593671619917905917L, 255L, 0L, 0L, 0L};
9297.            return data;
9298.        }
9299.        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
9300.        private static final long[] mk_tokenSet_22() {
9301.            long[] data = { 1080864392243348064L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9302.            return data;
9303.        }
9304.        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
9305.        private static final long[] mk_tokenSet_23() {
9306.            long[] data = { 1152921503532220304L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9307.            return data;
9308.        }
9309.        public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
9310.        private static final long[] mk_tokenSet_24() {
9311.            long[] data = { -8070450533322321024L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9312.            return data;
9313.        }
9314.        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
9315.        private static final long[] mk_tokenSet_25() {
9316.            long[] data = { 1080863912280837728L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9317.            return data;
9318.        }
9319.        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
9320.        private static final long[] mk_tokenSet_26() {
9321.            long[] data = { -14L, -1048577L, 16383L, 0L, 0L, 0L};
9322.            return data;
9323.        }
9324.        public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
9325.        private static final long[] mk_tokenSet_27() {
9326.            long[] data = { 7344640L, 18014398509482000L, 0L, 0L};
9327.            return data;
9328.        }
9329.        public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
9330.        private static final long[] mk_tokenSet_28() {
9331.            long[] data = { 144115186464330624L, 18014398509481984L, 0L, 0L};
9332.            return data;
9333.        }
9334.        public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
9335.        private static final long[] mk_tokenSet_29() {
9336.            long[] data = { 1080863910568919552L, 18014398509481984L, 0L, 0L};
9337.            return data;
9338.        }
9339.        public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
9340.        private static final long[] mk_tokenSet_30() {
9341.            long[] data = { 1080863911106349664L, 3557280738472624151L, 256L, 0L, 0L, 0L};
9342.            return data;
9343.        }
9344.        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
9345.        private static final long[] mk_tokenSet_31() {
9346.            long[] data = { 1152921501384777632L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9347.            return data;
9348.        }
9349.        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
9350.        private static final long[] mk_tokenSet_32() {
9351.            long[] data = { -8133501338408189440L, 4501453380673077275L, 16128L, 0L, 0L, 0L};
9352.            return data;
9353.        }
9354.        public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
9355.        private static final long[] mk_tokenSet_33() {
9356.            long[] data = { 1080863912280836704L, -1053842312821473217L, 511L, 0L, 0L, 0L};
9357.            return data;
9358.        }
9359.        public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
9360.        private static final long[] mk_tokenSet_34() {
9361.            long[] data = { 9006649901580288L, 0L, 0L};
9362.            return data;
9363.        }
9364.        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
9365.        private static final long[] mk_tokenSet_35() {
9366.            long[] data = { 9223372035780139920L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9367.            return data;
9368.        }
9369.        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
9370.        private static final long[] mk_tokenSet_36() {
9371.            long[] data = { 9223372035780123536L, -4593671619915808749L, 255L, 0L, 0L, 0L};
9372.            return data;
9373.        }
9374.        public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
9375.        private static final long[] mk_tokenSet_37() {
9376.            long[] data = { 1080863912280836704L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9377.            return data;
9378.        }
9379.        public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
9380.        private static final long[] mk_tokenSet_38() {
9381.            long[] data = { 1080863912280837728L, -4476578029623050177L, 255L, 0L, 0L, 0L};
9382.            return data;
9383.        }
9384.        public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
9385.        private static final long[] mk_tokenSet_39() {
9386.            long[] data = { 1080864392242790944L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9387.            return data;
9388.        }
9389.        public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
9390.        private static final long[] mk_tokenSet_40() {
9391.            long[] data = { 1080863911105790464L, 18014398509482000L, 0L, 0L};
9392.            return data;
9393.        }
9394.        public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
9395.        private static final long[] mk_tokenSet_41() {
9396.            long[] data = { 1080863912280754784L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9397.            return data;
9398.        }
9399.        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
9400.        private static final long[] mk_tokenSet_42() {
9401.            long[] data = { -8133501338408189440L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9402.            return data;
9403.        }
9404.        public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
9405.        private static final long[] mk_tokenSet_43() {
9406.            long[] data = { -8070450532247938080L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9407.            return data;
9408.        }
9409.        public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
9410.        private static final long[] mk_tokenSet_44() {
9411.            long[] data = { -8133501338408123904L, 4501453380673077267L, 16128L, 0L, 0L, 0L};
9412.            return data;
9413.        }
9414.        public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
9415.        private static final long[] mk_tokenSet_45() {
9416.            long[] data = { 1080863911206453760L, -4593671619917905901L, 255L, 0L, 0L, 0L};
9417.            return data;
9418.        }
9419.        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
9420.        private static final long[] mk_tokenSet_46() {
9421.            long[] data = { 1080864392243350112L, -1054405279954763753L, 511L, 0L, 0L, 0L};
9422.            return data;
9423.        }
9424.        public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
9425.        private static final long[] mk_tokenSet_47() {
9426.            long[] data = { 72057592426438528L, 18014398511579200L, 0L, 0L};
9427.            return data;
9428.        }
9429.        public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
9430.        private static final long[] mk_tokenSet_48() {
9431.            long[] data = { 1152921502459008992L, -4593671619917905865L, 255L, 0L, 0L, 0L};
9432.            return data;
9433.        }
9434.        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
9435.        private static final long[] mk_tokenSet_49() {
9436.            long[] data = { 1080864393317089888L, -1054405279954763721L, 511L, 0L, 0L, 0L};
9437.            return data;
9438.        }
9439.        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
9440.        private static final long[] mk_tokenSet_50() {
9441.            long[] data = { 1711833664L, -4593671619917905881L, 255L, 0L, 0L, 0L};
9442.            return data;
9443.        }
9444.        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
9445.        private static final long[] mk_tokenSet_51() {
9446.            long[] data = { -8070450532247937056L, -108086391071571841L, 16383L, 0L, 0L, 0L};
9447.            return data;
9448.        }
9449.        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
9450.        private static final long[] mk_tokenSet_52() {
9451.            long[] data = { 524864L, 0L, 0L};
9452.            return data;
9453.        }
9454.        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
9455.        private static final long[] mk_tokenSet_53() {
9456.            long[] data = { 1152921503532192640L, -4593671619917905869L, 255L, 0L, 0L, 0L};
9457.            return data;
9458.        }
9459.        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
9460.        private static final long[] mk_tokenSet_54() {
9461.            long[] data = { 638059104L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9462.            return data;
9463.        }
9464.        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
9465.        private static final long[] mk_tokenSet_55() {
9466.            long[] data = { 9006649901580800L, 18014398509481984L, 0L, 0L};
9467.            return data;
9468.        }
9469.        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
9470.        private static final long[] mk_tokenSet_56() {
9471.            long[] data = { 9006650539639392L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9472.            return data;
9473.        }
9474.        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
9475.        private static final long[] mk_tokenSet_57() {
9476.            long[] data = { 1152921501385234400L, -4593671619917905897L, 255L, 0L, 0L, 0L};
9477.            return data;
9478.        }
9479.        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
9480.        private static final long[] mk_tokenSet_58() {
9481.            long[] data = { -8070450533321763872L, 4611686001230741527L, 16128L, 0L, 0L, 0L};
9482.            return data;
9483.        }
9484.        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
9485.        private static final long[] mk_tokenSet_59() {
9486.            long[] data = { -8070450533322317952L, 4501453380688804819L, 16128L, 0L, 0L, 0L};
9487.            return data;
9488.        }
9489.        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
9490.        private static final long[] mk_tokenSet_60() {
9491.            long[] data = { -8070450533321761824L, 4611686018410610711L, 16128L, 0L, 0L, 0L};
9492.            return data;
9493.        }
9494.        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
9495.        private static final long[] mk_tokenSet_61() {
9496.            long[] data = { -8070450533322301568L, 4501453380688805843L, 16128L, 0L, 0L, 0L};
9497.            return data;
9498.        }
9499.        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
9500.        private static final long[] mk_tokenSet_62() {
9501.            long[] data = { -1073741838L, -41L, 16383L, 0L, 0L, 0L};
9502.            return data;
9503.        }
9504.        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
9505.        private static final long[] mk_tokenSet_63() {
9506.            long[] data = { -16400L, -1L, 536870911L, 0L, 0L, 0L};
9507.            return data;
9508.        }
9509.        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
9510.        private static final long[] mk_tokenSet_64() {
9511.            long[] data = { 96L, 6597069766656L, 0L, 0L};
9512.            return data;
9513.        }
9514.        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
9515.        private static final long[] mk_tokenSet_65() {
9516.            long[] data = { 0L, 422212465065985L, 0L, 0L};
9517.            return data;
9518.        }
9519.        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
9520.        private static final long[] mk_tokenSet_66() {
9521.            long[] data = { 9007130937917952L, 18014398509481984L, 0L, 0L};
9522.            return data;
9523.        }
9524.        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
9525.        private static final long[] mk_tokenSet_67() {
9526.            long[] data = { -8133501338408189440L, 1026820715040473104L, 15872L, 0L, 0L, 0L};
9527.            return data;
9528.        }
9529.        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
9530.        private static final long[] mk_tokenSet_68() {
9531.            long[] data = { -8133501337333806496L, 4611686018410610751L, 16128L, 0L, 0L, 0L};
9532.            return data;
9533.        }
9534.        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
9535.        private static final long[] mk_tokenSet_69() {
9536.            long[] data = { 0L, 1153027057723113491L, 0L, 0L};
9537.            return data;
9538.        }
9539.        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
9540.        private static final long[] mk_tokenSet_70() {
9541.            long[] data = { 0L, 2323857407723175936L, 256L, 0L, 0L, 0L};
9542.            return data;
9543.        }
9544.        public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
9545.        private static final long[] mk_tokenSet_71() {
9546.            long[] data = { -8070450533322321024L, 4501453380673077271L, 16128L, 0L, 0L, 0L};
9547.            return data;
9548.        }
9549.        public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
9550.        private static final long[] mk_tokenSet_72() {
9551.            long[] data = { 9006650438451744L, 18014398509481984L, 0L, 0L};
9552.            return data;
9553.        }
9554.        public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
9555.        private static final long[] mk_tokenSet_73() {
9556.            long[] data = { -8142508125748723200L, 18014398509482000L, 15872L, 0L, 0L, 0L};
9557.            return data;
9558.        }
9559.        public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
9560.        private static final long[] mk_tokenSet_74() {
9561.            long[] data = { 137438953472L, 1008806316530991104L, 0L, 0L};
9562.            return data;
9563.        }
9564.        public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
9565.        private static final long[] mk_tokenSet_75() {
9566.            long[] data = { 72057592963273600L, 18014398509481984L, 0L, 0L};
9567.            return data;
9568.        }
9569.        public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
9570.        private static final long[] mk_tokenSet_76() {
9571.            long[] data = { 1152921504606576608L, -4591419820120997825L, 255L, 0L, 0L, 0L};
9572.            return data;
9573.        }
9574.        public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
9575.        private static final long[] mk_tokenSet_77() {
9576.            long[] data = { 100663808L, -4593671619917905913L, 255L, 0L, 0L, 0L};
9577.            return data;
9578.        }
9579.        public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
9580.        private static final long[] mk_tokenSet_78() {
9581.            long[] data = { -8133500993635759520L, -108086391073669057L, 16383L, 0L, 0L, 0L};
9582.            return data;
9583.        }
9584.        public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
9585.        private static final long[] mk_tokenSet_79() {
9586.            long[] data = { 1611253856L, 2251799796908075L, 0L, 0L};
9587.            return data;
9588.        }
9589.        public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
9590.        
9591.        }